release: bump 0.5.0 -> 0.5.1 (#162)

Version bump **0.5.0 → 0.5.1** for the Seasonality & Session family release (12 indicators, PR #161).

Bumped: `Cargo.toml` (workspace version + `wickra-core` dep), `Cargo.lock` (via `cargo build`), `bindings/python/pyproject.toml`, `bindings/node/package.json` (+ 6 `optionalDependencies`), the 6 `bindings/node/npm/<platform>/package.json`, both `package-lock.json` files, and `CHANGELOG.md` (`[Unreleased]` → `[0.5.1]` + compare URLs).

No code changes — version strings only.

.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/PULL_REQUEST_TEMPLATE/detailed.md

@@ -60,7 +60,7 @@ Closes #
 - [ ] Public API changes are reflected in `CHANGELOG.md`
 - [ ] Public API changes are reflected in rustdoc / README / examples
 - [ ] No `todo*.md` or other local-only notes are staged
-- [ ] License header / `LICENSE` reference unchanged (PolyForm-NC-1.0.0)
+- [ ] License header / `LICENSE` reference unchanged (MIT OR Apache-2.0)
 
 ## 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/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,6 +49,8 @@ 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
 
@@ -44,6 +64,8 @@ jobs:
         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'
@@ -57,11 +79,15 @@ jobs:
         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

.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
@@ -68,6 +90,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Set up Node
         id: setup_node
@@ -155,6 +179,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
@@ -233,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
@@ -256,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
@@ -295,6 +325,8 @@ 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@bb137d7af7e4fb67e5f82a49c4fce4fad40782fe # v2.0.20
@@ -311,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
@@ -367,6 +401,8 @@ 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
@@ -387,6 +423,8 @@ jobs:
         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'
@@ -400,11 +438,21 @@ jobs:
         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
@@ -429,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
@@ -475,6 +525,8 @@ 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
@@ -494,6 +546,8 @@ jobs:
         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'
@@ -507,10 +561,12 @@ jobs:
         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

@@ -12,6 +12,13 @@ on:
   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 }})
@@ -33,7 +40,9 @@ jobs:
             build-mode: none
     steps:
       - name: Checkout
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@03e4368ac7daa2bd82b3e85262f3bf87ee112f57 # v3.36.0

.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,6 +46,8 @@ 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
@@ -134,6 +158,8 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
       - name: Set up Python
         id: setup_python
         continue-on-error: true
@@ -172,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
@@ -222,6 +250,8 @@ jobs:
     runs-on: ${{ matrix.host }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Set up Node
         id: setup_node
@@ -253,7 +283,7 @@ jobs:
 
       - name: Install Node deps
         working-directory: bindings/node
-        run: npm install
+        run: npm ci
 
       - name: Build native module
         working-directory: bindings/node
@@ -281,6 +311,8 @@ jobs:
       id-token: write
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Set up Node
         id: setup_node
@@ -306,7 +338,7 @@ jobs:
 
       - 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
@@ -448,6 +480,8 @@ jobs:
       id-token: write
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Set up Node
         id: setup_node
@@ -502,7 +536,7 @@ jobs:
             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';
+            pkg.license = 'MIT OR Apache-2.0';
             fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
           "
 
@@ -527,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)
@@ -578,7 +632,7 @@ jobs:
           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 }}
@@ -586,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.
 
@@ -618,18 +675,26 @@ jobs:
   # --------------------------------------------------------------------------
   attestations:
     name: Attest build provenance
-    needs: [cargo-publish, python-wheels, python-sdist]
+    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. This job is
-    # isolated and runs *after* the publishes on the exact uploaded bytes, so a
-    # failure here can never block or corrupt a publish (same isolation that the
-    # SBOM step lacked before #79).
+    # 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: read
+      contents: write # upload the provenance bundle as a release asset
     steps:
       - name: Download crate files
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
@@ -643,9 +708,70 @@ jobs:
           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
+            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

@@ -24,7 +24,7 @@ jobs:
       id-token: write # OIDC token to publish results to the OpenSSF API
     steps:
       - name: Checkout code
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
 

.github/workflows/sync-about.yml

@@ -10,7 +10,7 @@ name: Sync indicator count
 #   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 / public/hero.svg) — push to main / v* tag*
+#      .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.")
@@ -20,10 +20,15 @@ name: Sync indicator count
 #                                            — 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.
+#   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.
@@ -36,17 +41,17 @@ name: Sync indicator count
 # `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.
+# Design: on PRs this workflow is a READ-ONLY check. The indicator wiring
+# (ScriptHelpers/_common.py wire_readme_counter) bumps both README.md and
+# docs/README.md inside the author's code commit, so the counter is already
+# correct by the time CI runs. If it is not, the check below fails loud and
+# asks the author to re-run the wiring — it never pushes a fix-up commit.
 #
-# 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).
+# (An earlier version pushed a GITHUB_TOKEN "sync indicator count" commit to
+# the PR head. Because GITHUB_TOKEN pushes trigger no workflows, that commit
+# moved the PR head onto a commit with no CI run, which hid the Codecov patch
+# status — keyed to the PR head sha — from the PR. Keeping the counter in the
+# code commit avoids that entirely.)
 on:
   push:
     branches: [main]
@@ -55,60 +60,37 @@ on:
     types: [opened, synchronize, reopened]
   workflow_dispatch:
 
-# `contents: write` is needed so the workflow can push the counter
-# fix-up commit to the PR head branch via the auto-provided
-# GITHUB_TOKEN. The wider About / Wiki writes still go through the
-# fine-grained PAT (ABOUT_SYNC_TOKEN) because they need
-# `Administration: write` (gh repo edit) which GITHUB_TOKEN lacks.
+# 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: write
+  contents: read
   pull-requests: read
 
 jobs:
   sync:
     runs-on: ubuntu-latest
+    # This workflow never writes to wickra-lib/wickra with GITHUB_TOKEN: the PR
+    # flow is a read-only check, and the main/tag flow writes only to other
+    # repos (About metadata, docs, webpage, wiki, org) through the fine-grained
+    # ABOUT_SYNC_TOKEN PAT. So GITHUB_TOKEN stays read-only (OpenSSF Scorecard:
+    # Token-Permissions).
+    permissions:
+      contents: read
+      pull-requests: read
     steps:
-      # On PRs 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".
+      # On PRs we check out the PR *head* commit (the author's code, not the
+      # merge ref) so the counter check validates exactly what will land. On
+      # push events we check out the default ref. No push is made, so a shallow
+      # checkout is enough.
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          fetch-depth: 0
+          fetch-depth: 1
           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
@@ -128,62 +110,33 @@ jobs:
 
       # ----- PR flow ---------------------------------------------------
 
-      - name: Check README counter (PR)
+      - name: Check README counter (PR, read-only)
         if: github.event_name == 'pull_request'
-        id: pr_check
         run: |
           n="${{ steps.count.outputs.count }}"
-          if grep -qE "^${n} streaming-first indicators" README.md; then
-            echo "matches=true" >> "$GITHUB_OUTPUT"
-            echo "README counter already at ${n}; nothing to do."
-          else
-            echo "matches=false" >> "$GITHUB_OUTPUT"
-            echo "README counter does not match ${n}; will fix up."
+          ok=true
+          if ! grep -qE "^${n} streaming-first indicators" README.md; then
+            echo "::error::README.md does not say '${n} streaming-first indicators' — lib.rs exports ${n}. Re-run the indicator wiring (it bumps README.md), then push again."
+            ok=false
           fi
-
-      - name: Fix counter on fork PR head (read-only, fail loud)
-        if: github.event_name == 'pull_request' && steps.pr_check.outputs.matches == 'false' && steps.ctx.outputs.can_push == 'false'
-        run: |
-          n="${{ steps.count.outputs.count }}"
-          echo "::error::README.md says a different indicator count than mod.rs (${n}). This PR is from a fork, so the workflow cannot push the fix; please update README.md to '${n} streaming-first indicators' and push again."
-          exit 1
-
-      - name: Patch README on PR head
-        if: github.event_name == 'pull_request' && steps.pr_check.outputs.matches == 'false' && steps.ctx.outputs.can_push == 'true'
-        id: pr_patch
-        run: |
-          n="${{ steps.count.outputs.count }}"
-          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" README.md
-          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"
+          if ! grep -qE "\*\*${n} indicators\*\*" docs/README.md; then
+            echo "::error::docs/README.md does not say '**${n} indicators**' — lib.rs exports ${n}. Re-run the indicator wiring (it bumps docs/README.md), then push again."
+            ok=false
+          fi
+          if [ "$ok" = "true" ]; then
+            echo "README.md + docs/README.md counter already at ${n}; nothing to do."
+          else
+            exit 1
           fi
-
-      - name: Commit & push counter fix to PR head
-        if: github.event_name == 'pull_request' && steps.pr_patch.outputs.changed == 'true'
-        # head_ref still carries the (untrusted) PR branch name forwarded by the
-        # ctx step; pass it through the environment so the push refspec cannot be
-        # used to inject shell commands (OpenSSF Scorecard: Dangerous-Workflow).
-        env:
-          COUNT: ${{ steps.count.outputs.count }}
-          HEAD_REF: ${{ steps.ctx.outputs.head_ref }}
-        run: |
-          git config user.name "wickra-bot"
-          git config user.email "wickra-bot@users.noreply.github.com"
-          git add README.md
-          git commit -m "chore: sync indicator count to ${COUNT}"
-          git push origin "HEAD:${HEAD_REF}"
 
       # ----- main / tag flow ------------------------------------------
       #
-      # After a PR squash-merges, this workflow runs again on the push
-      # to main. README is already correct (it was fixed on the PR
-      # branch before the merge); the only outward syncs left are the
-      # GitHub About description (repo metadata, not a commit) and the
-      # wiki repo (separate repo, no main history pollution). README is
-      # not touched on main any more.
+      # After a PR squash-merges, this workflow runs again on the push to main.
+      # README.md / docs/README.md are already correct (the indicator wiring
+      # bumped them in the merged code commit); the only outward syncs left are
+      # the GitHub About description (repo metadata, not a commit) and the docs /
+      # webpage / wiki / org repos (separate repos, no main history pollution).
+      # The wickra repo's own README is not touched on main any more.
 
       - name: Update GitHub About (description + homepage)
         if: github.event_name != 'pull_request'
@@ -242,6 +195,40 @@ jobs:
             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
@@ -325,11 +312,19 @@ jobs:
             echo "::warning::tag '${GITHUB_REF}' is not a plain vMAJOR.MINOR.PATCH release; skipping docs version sync."
             exit 0
           fi
-          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/wickra-docs.git" docs 2>/dev/null; then
+          # 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
+          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
@@ -371,14 +366,14 @@ jobs:
             exit 0
           fi
           cd webpage-count
-          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" index.md .vitepress/config.ts public/hero.svg
+          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 public/hero.svg
+          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)."
@@ -397,6 +392,26 @@ jobs:
             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
@@ -409,13 +424,25 @@ jobs:
           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
+          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)."

.github/workflows/sync-metadata.yml

@@ -15,6 +15,8 @@ jobs:
     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"

.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

CHANGELOG.md

@@ -7,6 +7,322 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.1] - 2026-06-03
+
+### Added — Seasonality & Session family (12 indicators)
+
+- **Volume-by-Time Profile** — mean traded volume bucketed by intraday time (`VOLUME_BY_TIME_PROFILE`).
+- **Intraday Volatility Profile** — return standard deviation bucketed by intraday time (`INTRADAY_VOLATILITY_PROFILE`).
+- **Day-of-Week Profile** — mean bar return bucketed by weekday (`DAY_OF_WEEK_PROFILE`).
+- **Time-of-Day Return Profile** — mean bar return bucketed by intraday time (`TIME_OF_DAY_RETURN_PROFILE`).
+- **Seasonal Z-Score** — z-score of the current return versus the same hour-of-day history (`SEASONAL_Z_SCORE`).
+- **Turn-of-Month** — mean daily return inside the turn-of-month window (`TURN_OF_MONTH`).
+- **Overnight/Intraday Return** — decomposition of session return into overnight and intraday legs (`OVERNIGHT_INTRADAY_RETURN`).
+- **Overnight Gap** — close-to-open return across the session boundary (`OVERNIGHT_GAP`).
+- **Average Daily Range** — mean high-low range of the last N completed sessions (`AVERAGE_DAILY_RANGE`).
+- **Session Range** — per-session (Asia/EU/US) high-low range (`SESSION_RANGE`).
+- **Session High/Low** — running high and low of the current session (`SESSION_HIGH_LOW`).
+- **Session VWAP** — session-anchored volume-weighted average price (`SESSION_VWAP`).
+
+## [0.5.0] - 2026-06-03
+
+### Added
+- **TICK Index** — instantaneous net advancing-minus-declining issues (`TICK_INDEX`).
+- **Absolute Breadth Index** — absolute value of net advancing-minus-declining issues (`ABSOLUTE_BREADTH_INDEX`).
+- **Cumulative Volume Index** — running total of volume-normalised net advancing volume (`CUMULATIVE_VOLUME_INDEX`).
+- **Bullish Percent Index** — percentage of the universe on a point-and-figure buy signal (`BULLISH_PERCENT_INDEX`).
+- **Up/Down Volume Ratio** — advancing volume divided by declining volume (`UP_DOWN_VOLUME_RATIO`).
+- **Percent Above Moving Average** — percentage of the universe trading above its reference moving average (`PERCENT_ABOVE_MA`).
+- **High-Low Index** — moving average of the record-high percentage (`HIGH_LOW_INDEX`).
+- **New Highs - New Lows** — net count of new period highs minus new period lows (`NEW_HIGHS_NEW_LOWS`).
+- **Breadth Thrust** — moving average of the advancing-issues share (Zweig) (`BREADTH_THRUST`).
+- **TRIN / Arms Index** — advance-decline ratio divided by the up-down volume ratio (`TRIN`).
+- **McClellan Summation Index** — running cumulative total of the McClellan Oscillator (`MCCLELLAN_SUMMATION_INDEX`).
+- **McClellan Oscillator** — spread between a 19- and 39-period EMA of ratio-adjusted net advances (`MCCLELLAN_OSCILLATOR`).
+- **Advance/Decline Volume Line** — cumulative net advancing-minus-declining volume across the universe (`AD_VOLUME_LINE`).
+- **Advance/Decline Ratio** — advancing issues divided by declining issues across the universe (`ADVANCE_DECLINE_RATIO`).
+
+### Changed
+- **Relicensed** from PolyForm Noncommercial 1.0.0 to dual **MIT OR Apache-2.0**. Wickra is now OSI-approved, permissive open source; commercial use is permitted under either license. See [`LICENSE-MIT`](LICENSE-MIT) and [`LICENSE-APACHE`](LICENSE-APACHE).
+
+## [0.4.7] - 2026-06-03
+
+### Added
+- **Spread Bollinger Bands** — Bollinger bands on the spread of two series for pairs mean-reversion (`SPREAD_BOLLINGER_BANDS`).
+- **Kalman Hedge Ratio** — Kalman-filter dynamic hedge ratio and spread between two series (`KALMAN_HEDGE_RATIO`).
+- **Granger Causality** — Granger causality F-statistic measuring whether one series predicts another (`GRANGER_CAUSALITY`).
+- **Variance Ratio** — Lo-MacKinlay variance-ratio test on the spread of two series (`VARIANCE_RATIO`).
+- **Beta-Neutral Spread** — beta-neutral spread: the rolling OLS regression residual of two series (`BETA_NEUTRAL_SPREAD`).
+- **Distance SSD** — Gatev sum-of-squared-deviations distance between two normalised series (`DISTANCE_SSD`).
+- **Spread Hurst** — Hurst exponent of the spread of two series for regime detection (`SPREAD_HURST`).
+- **OU Half-Life** — Ornstein-Uhlenbeck half-life of mean reversion for the spread of two series (`OU_HALF_LIFE`).
+- **Rolling Covariance** — rolling covariance of the period-over-period returns of two series (`ROLLING_COVARIANCE`).
+- **Rolling Correlation** — rolling Pearson correlation of the period-over-period returns of two series (`ROLLING_CORRELATION`).
+
+- **Market Breadth family** — a new indicator family built on a new
+  `CrossSection` input type that carries the per-symbol state of an entire
+  universe in one tick (each `Member` holds a signed `change`, a `volume`, and
+  `new_high` / `new_low` flags). `CrossSection::new` validates the universe
+  (non-empty, finite changes, finite non-negative volumes); `new_unchecked`
+  skips validation for hot paths.
+  - `AdvanceDecline` (`ADVANCE_DECLINE`) — the Advance/Decline Line, the running
+    cumulative sum of net advancing-minus-declining issues across the universe.
+
+## [0.4.6] - 2026-06-03
+
+### Added
+
+- **TA-Lib parity — Directional Movement components** — the ADX building blocks,
+  previously available only bundled inside `Adx`, as standalone single-output
+  indicators:
+  - `PlusDm` (`PLUS_DM`) — Wilder-smoothed plus directional movement.
+  - `MinusDm` (`MINUS_DM`) — Wilder-smoothed minus directional movement.
+  - `PlusDi` (`PLUS_DI`) — plus directional indicator, `100 · smoothed(+DM) / ATR`.
+  - `MinusDi` (`MINUS_DI`) — minus directional indicator, `100 · smoothed(-DM) / ATR`.
+  - `Dx` (`DX`) — directional movement index, `100 · |+DI − −DI| / (+DI + −DI)`.
+- **TA-Lib parity — price transforms** — window and per-bar price aggregates:
+  - `MidPrice` (`MIDPRICE`) — `(highest high + lowest low) / 2` over a window.
+  - `MidPoint` (`MIDPOINT`) — `(max + min) / 2` of a scalar series over a window.
+  - `AvgPrice` (`AVGPRICE`) — per-bar `(open + high + low + close) / 4`.
+- **TA-Lib parity — rate-of-change variants** — the ratio forms of `Roc`:
+  - `Rocp` (`ROCP`) — `(close − close[period]) / close[period]` (fraction).
+  - `Rocr` (`ROCR`) — `close / close[period]` (ratio).
+  - `Rocr100` (`ROCR100`) — `close / close[period] · 100`.
+- **TA-Lib parity — linear-regression outputs** — the remaining OLS endpoints:
+  - `LinRegIntercept` (`LINEARREG_INTERCEPT`) — the OLS intercept `a`.
+  - `Tsf` (`TSF`) — time series forecast, `a + b·period` (one bar ahead).
+- **TA-Lib parity — `MacdFix` (`MACDFIX`)** — MACD with fast/slow fixed at 12/26
+  and only the signal period configurable; output is the usual `{macd, signal,
+  histogram}` triple.
+- **TA-Lib parity — `SarExt` (`SAREXT`)** — Parabolic SAR with a start value,
+  reversal offset, independent long/short acceleration, and a signed output
+  (positive in long phases, negative in short phases).
+- **TA-Lib parity — `MacdExt` (`MACDEXT`)** — MACD with an independently
+  selectable moving-average type (new `MaType` enum: SMA/EMA/WMA/DEMA/TEMA/TRIMA)
+  for each of the fast, slow and signal lines.
+- **TA-Lib parity — `HtPhasor` (`HT_PHASOR`)** — the in-phase and quadrature
+  components of the Hilbert-transform analytic signal, as a `{inphase,
+  quadrature}` pair.
+- **TA-Lib parity — `HtDcPhase` (`HT_DCPHASE`)** — the phase angle (in degrees)
+  of the Hilbert-transform dominant cycle.
+- **TA-Lib parity — `HtTrendMode` (`HT_TRENDMODE`)** — Ehlers' trend (`1`) vs
+  cycle (`0`) classification from the Hilbert-transform dominant cycle.
+
+## [0.4.5] - 2026-06-02
+
+### Added
+
+- **Anchored RSI** — a cumulative Relative Strength Index whose averaging begins at a runtime-chosen anchor bar (`set_anchor`), the momentum counterpart to Anchored VWAP. Every up- and down-move since the anchor is weighted equally, so it reports the RSI of the entire move since the anchor point. Scalar input, Momentum Oscillators family; available in Rust, Python, Node and WASM.
+- **Volume Profile** — the full per-bin volume distribution over a rolling window, exposing the raw histogram (price bounds plus per-bin volume) that Value Area reduces to POC/VAH/VAL. Market Profile family; candle input, available in Rust, Python, Node and WASM.
+- **TPO Profile** — the Time-Price-Opportunity (market-profile letter) distribution: a volume-agnostic count of how many periods traded at each price level over a rolling window. Market Profile family; candle input, available in Rust, Python, Node and WASM.
+- **Alt-Chart Bars** — a new `BarBuilder` trait and family of price-driven chart constructors that emit a variable number of completed bars per candle (so they are deliberately not `Indicator`s): **Renko** (fixed box-size bricks with the 2-box reversal rule), **Kagi** (reversal-amount line segments), and **Point & Figure** (box-size X/O columns with an N-box reversal). Available in Rust, Python, Node and WASM.
+
+## [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
@@ -869,7 +1185,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   optional Binance live feed.
 - Bindings for Python, Node.js, and WebAssembly.
 
-[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.5.1...HEAD
+[0.5.1]: https://github.com/wickra-lib/wickra/compare/v0.5.0...v0.5.1
+[0.5.0]: https://github.com/wickra-lib/wickra/compare/v0.4.7...v0.5.0
+[0.4.7]: https://github.com/wickra-lib/wickra/compare/v0.4.6...v0.4.7
+[0.4.6]: https://github.com/wickra-lib/wickra/compare/v0.4.5...v0.4.6
+[0.4.5]: https://github.com/wickra-lib/wickra/compare/v0.4.4...v0.4.5
+[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

CITATION.cff

@@ -26,4 +26,6 @@ keywords:
   - quantitative-finance
   - rust
   - time-series
-license: PolyForm-Noncommercial-1.0.0
+license:
+  - MIT
+  - Apache-2.0

CONTRIBUTING.md

@@ -5,11 +5,11 @@ build the project, the standards a change must meet, and how to get it merged.
 
 ## License of contributions
 
-Wickra is licensed under the **PolyForm Noncommercial License 1.0.0** (see
-[`LICENSE`](LICENSE)). By submitting a contribution you agree that it is
-licensed to the project under those same terms. The Noncommercial license
-permits use for any purpose **other than** a commercial one; keep that in mind
-when proposing features or depending on Wickra elsewhere.
+Wickra is dual-licensed under the [MIT](LICENSE-MIT) and
+[Apache-2.0](LICENSE-APACHE) licenses; users may choose either. Unless you
+explicitly state otherwise, any contribution you intentionally submit for
+inclusion in the work, as defined in the Apache-2.0 license, shall be dual
+licensed as above, without any additional terms or conditions.
 
 ## Project layout
 
@@ -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
 
@@ -75,7 +75,8 @@ wasm-pack test --node bindings/wasm
 | 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) | PyO3 convention: the Python package has no Python runtime dependencies of its own, and its native code is already pinned through the workspace `Cargo.lock`. CI installs build/test tooling (`maturin`, `pytest`, `numpy`, `hypothesis`) directly via `pip`. |
+| `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. |
 
@@ -83,6 +84,13 @@ When adding a new committed Node package, commit its `package-lock.json` too and
 remove any matching ignore rule. Do **not** add a top-level `package-lock.json` —
 the repository root is not an npm package.
 
+To refresh every committed lockfile in the workspace — `Cargo.lock`,
+`fuzz/Cargo.lock`, the Node binding lock, and the hash-pinned Python
+requirements — run `./scripts/update-lockfiles.sh`. It uses `uv` for the Python
+locks (and bootstraps it on Linux/macOS if absent) so each target Python
+version's hashed transitive closure can be regenerated without that interpreter
+installed. Dependabot also keeps the `.github/requirements` pins current.
+
 ## Standards for a change
 
 - **Formatting & lints.** `cargo fmt` must leave the tree unchanged and

Cargo.lock

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

Cargo.toml

@@ -12,11 +12,11 @@ members = [
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.4.0"
+version = "0.5.1"
 authors = ["kingchenc <support@wickra.org>"]
 edition = "2021"
 rust-version = "1.86"
-license = "PolyForm-Noncommercial-1.0.0"
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/wickra-lib/wickra"
 homepage = "https://github.com/wickra-lib/wickra"
 readme = "README.md"
@@ -24,7 +24,7 @@ keywords = ["finance", "trading", "indicators", "technical-analysis", "ta"]
 categories = ["finance", "mathematics", "science"]
 
 [workspace.dependencies]
-wickra-core = { path = "crates/wickra-core", version = "0.4.0" }
+wickra-core = { path = "crates/wickra-core", version = "0.5.1" }
 
 thiserror = "2"
 rayon = "1.10"

LICENSE

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

LICENSE-APACHE

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

LICENSE-MIT

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

LICENSES/Apache-2.0.txt

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

LICENSES/MIT.txt

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

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://wickra.org"><img src="https://wickra.org/og-banner.webp" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=351" alt="Wickra — streaming-first technical indicators" width="100%"></a>
 </p>
 
 [![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
@@ -9,9 +9,10 @@
 [![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)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](#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.**
 
@@ -37,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 351 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,
@@ -115,28 +135,40 @@ python -m benchmarks.compare_libraries
 
 ## Indicators
 
-214 streaming-first indicators across sixteen families. Every one passes the
+351 streaming-first indicators across twenty-one 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, 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 |
+| Momentum Oscillators | RSI (Wilder), Anchored RSI, Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator, RVI, PGO, KST, SMI, Laguerre RSI, Connors RSI, Inertia, ROC Percentage (ROCP), ROC Ratio (ROCR), ROC Ratio 100 (ROCR100) |
+| Trend & Directional  | MACD, MACD Fixed (MACDFIX), MACD Extended (MACDEXT), ADX (+DI/-DI), ADXR, Aroon, TRIX, Aroon Oscillator, Vortex, Random Walk Index, Trend Intensity Index, Wave Trend Oscillator, Mass Index, Choppiness Index, Vertical Horizontal Filter, Plus DM, Minus DM, Plus DI, Minus DI, DX |
 | 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 |
+| Trailing Stops       | Parabolic SAR, Parabolic SAR Extended (SAREXT), SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop, HiLo Activator, Volty Stop, Yo-Yo Exit, Donchian Channel Stop, Percentage Trailing Stop, Step Trailing Stop, Renko Trailing Stop |
 | 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, 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 |
+| Price Statistics     | Typical Price, Median Price, Weighted Close, Linear Regression, Linear Regression Slope, Z-Score, Linear Regression Angle, Variance, Coefficient of Variation, Skewness, Kurtosis, Standard Error, Detrended StdDev, R², Median Absolute Deviation, Autocorrelation, Hurst Exponent, Pearson Correlation, Beta, Pairwise Beta, Pair Spread Z-Score, Lead-Lag Cross-Correlation, Cointegration, Relative Strength A-vs-B, Spearman Correlation, Mid Price, Mid Point, Average Price, Linear Regression Intercept, Time Series Forecast, Rolling Correlation, Rolling Covariance, OU Half-Life, Spread Hurst, Distance SSD, Beta-Neutral Spread, Variance Ratio, Granger Causality, Kalman Hedge Ratio, Spread Bollinger Bands |
+| Ehlers / Cycle (DSP) | MAMA, FAMA, Fisher Transform, Inverse Fisher Transform, SuperSmoother, Hilbert Dominant Cycle, Hilbert Phasor, Hilbert DC Phase, Hilbert Trend Mode, Sine Wave, Decycler, Decycler Oscillator, Roofing Filter, Center of Gravity, Cybernetic Cycle, Adaptive Cycle, Empirical Mode Decomposition, Ehlers Stochastic, Instantaneous Trendline |
 | 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 |
-| Market Profile       | Value Area (POC / VAH / VAL), Initial Balance, Opening Range |
+| Alt-Chart Bars       | Renko (box-size bricks), Kagi (reversal-amount lines), Point & Figure (X/O columns) |
+| 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), Volume Profile (histogram), TPO Profile, Initial Balance, Opening Range |
+| Market Breadth       | Advance/Decline Line, Advance/Decline Ratio, Advance/Decline Volume Line, McClellan Oscillator, McClellan Summation Index, TRIN / Arms Index, Breadth Thrust, New Highs - New Lows, High-Low Index, Percent Above Moving Average, Up/Down Volume Ratio, Bullish Percent Index, Cumulative Volume Index, Absolute Breadth Index, TICK Index |
 | Risk / Performance   | Sharpe Ratio, Sortino Ratio, Calmar Ratio, Omega Ratio, Max Drawdown, Average Drawdown, Drawdown Duration, Pain Index, Value at Risk, Conditional Value at Risk (CVaR), Profit Factor, Gain/Loss Ratio, Recovery Factor, Kelly Criterion, Treynor Ratio, Information Ratio, Alpha (Jensen) |
+| Seasonality & Session | Session VWAP, Session High/Low, Session Range, Average Daily Range, Overnight Gap, Overnight/Intraday Return, Turn-of-Month, Seasonal Z-Score, Time-of-Day Return Profile, Day-of-Week Profile, Intraday Volatility Profile, Volume-by-Time Profile |
+
+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.
@@ -209,7 +241,7 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 214 indicators
+│   ├── wickra-core/         core engine + all 351 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 ├── bindings/
@@ -293,13 +325,20 @@ shape together before you invest the time.
 
 ## License
 
-Licensed under the **PolyForm Noncommercial License 1.0.0**. See [LICENSE](LICENSE).
+Licensed under either of
 
-In plain English: use it, fork it, modify it, redistribute it, file issues, send
-pull requests — all welcome. Personal projects, research, education, non-profits,
-government, hobby trading bots: all fine. The one thing that's not allowed is
-commercial sale of the software or of services built around it. If you want to
-use Wickra commercially, get in touch about a license.
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
+
+at your option. Use it, fork it, modify it, redistribute it — commercially or
+not — file issues, send pull requests; all welcome.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
 
 ## Disclaimer
 

SECURITY.md

@@ -2,13 +2,13 @@
 
 ## Supported versions
 
-Wickra is pre-1.0. Security fixes are applied to the latest released `0.1.x`
+Wickra is pre-1.0. Security fixes are applied to the latest released `0.5.x`
 version only; please upgrade to the newest release before reporting an issue.
 
 | Version | Supported |
 | --- | --- |
-| 0.1.x (latest) | :white_check_mark: |
-| older 0.1.x | :x: |
+| 0.5.x (latest) | :white_check_mark: |
+| older 0.5.x | :x: |
 
 ## Reporting a vulnerability
 

bindings/node/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
 [![npm](https://img.shields.io/npm/v/wickra.svg?logo=npm&color=red)](https://www.npmjs.com/package/wickra)
-[![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](https://github.com/wickra-lib/wickra/blob/main/LICENSE)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
 
 **Streaming-first technical indicators for Node.js. `npm install wickra` —
 prebuilt native binary, no system dependencies.**
@@ -67,7 +67,5 @@ risk. The library is provided **as is**, without warranty of any kind.
 
 ## License
 
-Licensed under the **PolyForm Noncommercial License 1.0.0**. Personal projects,
-research, education, non-profits, and hobby trading bots are all fine; the one
-thing not allowed is commercial sale of the software or of services built
-around it. See [LICENSE](https://github.com/wickra-lib/wickra/blob/main/LICENSE).
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/node/__tests__/completeness.test.js

@@ -8,16 +8,25 @@ const test = require('node:test');
 const assert = require('node:assert/strict');
 const wickra = require('..');
 
+// Bar builders (Renko / Kagi / Point & Figure) implement the `BarBuilder`
+// contract, not `Indicator`: they emit a variable number of completed bars per
+// candle and have no fixed warmup or ready state. They expose update/batch/reset
+// but intentionally not isReady/warmupPeriod, so they are excluded from the
+// Indicator completeness contract below (their interface is covered by the
+// dedicated bar-builder tests).
+const BAR_BUILDERS = new Set(['RenkoBars', 'KagiBars', 'PointAndFigureBars']);
+
 // 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.
+// streaming `update` method. This excludes `version` (a plain function), the bar
+// builders, 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'
+      typeof value.prototype.update === 'function' &&
+      !BAR_BUILDERS.has(name)
     );
   });
 }

bindings/node/__tests__/indicators.test.js

@@ -28,10 +28,17 @@ function num(v) {
 // --- Scalar indicators: update(value) vs batch(prices) ---
 
 const scalarFactories = {
+  TSF: () => new wickra.TSF(14),
+  LINEARREG_INTERCEPT: () => new wickra.LINEARREG_INTERCEPT(14),
+  ROCR100: () => new wickra.ROCR100(10),
+  ROCR: () => new wickra.ROCR(10),
+  ROCP: () => new wickra.ROCP(10),
+  MIDPOINT: () => new wickra.MIDPOINT(14),
   SMA: () => new wickra.SMA(14),
   EMA: () => new wickra.EMA(14),
   WMA: () => new wickra.WMA(14),
   RSI: () => new wickra.RSI(14),
+  AnchoredRSI: () => new wickra.AnchoredRSI(),
   DEMA: () => new wickra.DEMA(10),
   TEMA: () => new wickra.TEMA(10),
   HMA: () => new wickra.HMA(9),
@@ -89,6 +96,8 @@ const scalarFactories = {
   EhlersStochastic: () => new wickra.EhlersStochastic(20),
   EmpiricalModeDecomposition: () => new wickra.EmpiricalModeDecomposition(20, 0.5),
   HilbertDominantCycle: () => new wickra.HilbertDominantCycle(),
+  HT_DCPHASE: () => new wickra.HT_DCPHASE(),
+  HT_TRENDMODE: () => new wickra.HT_TRENDMODE(),
   AdaptiveCycle: () => new wickra.AdaptiveCycle(),
   SineWave: () => new wickra.SineWave(),
   FAMA: () => new wickra.FAMA(0.5, 0.05),
@@ -158,10 +167,17 @@ for (const [name, make] of Object.entries(scalarFactories)) {
 // --- Scalar-output candle indicators: update(...) vs batch(...) ---
 
 const candleScalar = {
+  MIDPRICE: { make: () => new wickra.MIDPRICE(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  DX: { make: () => new wickra.DX(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  MINUS_DI: { make: () => new wickra.MINUS_DI(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  PLUS_DI: { make: () => new wickra.PLUS_DI(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   ATR: { make: () => new wickra.ATR(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  PLUS_DM: { make: () => new wickra.PLUS_DM(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  MINUS_DM: { make: () => new wickra.MINUS_DM(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   CCI: { make: () => new wickra.CCI(20), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   WilliamsR: { make: () => new wickra.WilliamsR(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   PSAR: { make: () => new wickra.PSAR(0.02, 0.02, 0.2), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  SAREXT: { make: () => new wickra.SAREXT(0, 0, 0.02, 0.02, 0.2, 0.02, 0.02, 0.2), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   MFI: { make: () => new wickra.MFI(14), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
   VWAP: { make: () => new wickra.VWAP(), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
   RollingVWAP: { make: () => new wickra.RollingVWAP(20), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
@@ -169,6 +185,7 @@ const candleScalar = {
   OBV: { make: () => new wickra.OBV(), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
   VWMA: { make: () => new wickra.VWMA(20), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
   RVI: { make: () => new wickra.RVI(10), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  AVGPRICE: { make: () => new wickra.AVGPRICE(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
   Inertia: { make: () => new wickra.Inertia(14, 20), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
   PGO: { make: () => new wickra.PGO(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   SMI: { make: () => new wickra.SMI(5, 3, 3), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
@@ -235,6 +252,51 @@ const candleScalar = {
   SpinningTop: { make: () => new wickra.SpinningTop(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
   ThreeInside: { make: () => new wickra.ThreeInside(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
   ThreeOutside: { make: () => new wickra.ThreeOutside(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  TwoCrows: { make: () => new wickra.TwoCrows(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  UpsideGapTwoCrows: { make: () => new wickra.UpsideGapTwoCrows(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  IdenticalThreeCrows: { make: () => new wickra.IdenticalThreeCrows(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ThreeLineStrike: { make: () => new wickra.ThreeLineStrike(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ThreeStarsInSouth: { make: () => new wickra.ThreeStarsInSouth(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  AbandonedBaby: { make: () => new wickra.AbandonedBaby(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  AdvanceBlock: { make: () => new wickra.AdvanceBlock(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  BeltHold: { make: () => new wickra.BeltHold(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Breakaway: { make: () => new wickra.Breakaway(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Counterattack: { make: () => new wickra.Counterattack(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  DojiStar: { make: () => new wickra.DojiStar(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  DragonflyDoji: { make: () => new wickra.DragonflyDoji(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  GravestoneDoji: { make: () => new wickra.GravestoneDoji(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  LongLeggedDoji: { make: () => new wickra.LongLeggedDoji(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  RickshawMan: { make: () => new wickra.RickshawMan(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  EveningDojiStar: { make: () => new wickra.EveningDojiStar(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  MorningDojiStar: { make: () => new wickra.MorningDojiStar(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  GapSideBySideWhite: { make: () => new wickra.GapSideBySideWhite(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  HighWave: { make: () => new wickra.HighWave(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Hikkake: { make: () => new wickra.Hikkake(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  HikkakeModified: { make: () => new wickra.HikkakeModified(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  HomingPigeon: { make: () => new wickra.HomingPigeon(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  OnNeck: { make: () => new wickra.OnNeck(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  InNeck: { make: () => new wickra.InNeck(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Thrusting: { make: () => new wickra.Thrusting(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  SeparatingLines: { make: () => new wickra.SeparatingLines(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Kicking: { make: () => new wickra.Kicking(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  KickingByLength: { make: () => new wickra.KickingByLength(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  LadderBottom: { make: () => new wickra.LadderBottom(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  MatHold: { make: () => new wickra.MatHold(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  MatchingLow: { make: () => new wickra.MatchingLow(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  LongLine: { make: () => new wickra.LongLine(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ShortLine: { make: () => new wickra.ShortLine(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  RisingThreeMethods: { make: () => new wickra.RisingThreeMethods(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  FallingThreeMethods: { make: () => new wickra.FallingThreeMethods(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  UpsideGapThreeMethods: { make: () => new wickra.UpsideGapThreeMethods(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  DownsideGapThreeMethods: { make: () => new wickra.DownsideGapThreeMethods(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  StalledPattern: { make: () => new wickra.StalledPattern(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  StickSandwich: { make: () => new wickra.StickSandwich(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Takuri: { make: () => new wickra.Takuri(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ClosingMarubozu: { make: () => new wickra.ClosingMarubozu(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  OpeningMarubozu: { make: () => new wickra.OpeningMarubozu(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  TasukiGap: { make: () => new wickra.TasukiGap(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  UniqueThreeRiver: { make: () => new wickra.UniqueThreeRiver(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ConcealingBabySwallow: { make: () => new wickra.ConcealingBabySwallow(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
 };
 
 for (const [name, d] of Object.entries(candleScalar)) {
@@ -256,6 +318,9 @@ const multi = {
   Alligator: { make: () => new wickra.Alligator(13, 8, 5), fields: ['jaw', 'teeth', 'lips'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   ZeroLagMACD: { make: () => new wickra.ZeroLagMACD(12, 26, 9), fields: ['macd', 'signal', 'histogram'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   MACD: { make: () => new wickra.MACD(12, 26, 9), fields: ['macd', 'signal', 'histogram'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  HT_PHASOR: { make: () => new wickra.HT_PHASOR(), fields: ['inphase', 'quadrature'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  MACDFIX: { make: () => new wickra.MACDFIX(9), fields: ['macd', 'signal', 'histogram'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  MACDEXT: { make: () => new wickra.MACDEXT(12, 0, 26, 0, 9, 0), fields: ['macd', 'signal', 'histogram'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   KST: { make: () => wickra.KST.classic(), fields: ['kst', 'signal'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   BollingerBands: { make: () => new wickra.BollingerBands(20, 2), fields: ['upper', 'middle', 'lower', 'stddev'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   Stochastic: { make: () => new wickra.Stochastic(14, 3), fields: ['k', 'd'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
@@ -461,7 +526,17 @@ test('OpeningRange(2) breakout distance is signed close minus midpoint', () => {
 const pairFactories = {
   PearsonCorrelation: () => new wickra.PearsonCorrelation(14),
   Beta: () => new wickra.Beta(14),
+  PairwiseBeta: () => new wickra.PairwiseBeta(14),
+  PairSpreadZScore: () => new wickra.PairSpreadZScore(14, 14),
   SpearmanCorrelation: () => new wickra.SpearmanCorrelation(14),
+  RollingCorrelation: () => new wickra.RollingCorrelation(20),
+  RollingCovariance: () => new wickra.RollingCovariance(20),
+  OuHalfLife: () => new wickra.OuHalfLife(60),
+  SpreadHurst: () => new wickra.SpreadHurst(60),
+  DistanceSsd: () => new wickra.DistanceSsd(20),
+  BetaNeutralSpread: () => new wickra.BetaNeutralSpread(20),
+  VarianceRatio: () => new wickra.VarianceRatio(60, 2),
+  GrangerCausality: () => new wickra.GrangerCausality(60, 1),
 };
 
 for (const [name, make] of Object.entries(pairFactories)) {
@@ -492,6 +567,126 @@ test('Beta perfect two-to-one', () => {
   assert.ok(Math.abs(out[out.length - 1] - 2) < 1e-9);
 });
 
+test('PairwiseBeta squared price is two', () => {
+  // b needs varying returns; a = b² ⇒ a's log-returns are exactly 2× b's.
+  const bench = Array.from({ length: 20 }, (_, i) => 100 + 10 * Math.sin(i * 0.5));
+  const asset = bench.map((v) => v * v);
+  const out = new wickra.PairwiseBeta(5).batch(asset, bench);
+  assert.ok(Math.abs(out[out.length - 1] - 2) < 1e-9);
+});
+
+test('PairSpreadZScore flat benchmark is sign of last move', () => {
+  // Flat b ⇒ hedge ratio 0 ⇒ spread = ln(a); z_period = 2 ⇒ z = sign of move.
+  const a = [100, 100, 110, 105, 130];
+  const b = [100, 100, 100, 100, 100];
+  const out = new wickra.PairSpreadZScore(2, 2).batch(a, b);
+  assert.ok(Math.abs(out[out.length - 1] - 1) < 1e-9);
+  assert.ok(Math.abs(out[out.length - 2] + 1) < 1e-9);
+});
+
+const llSignal = (t) =>
+  Math.sin(t * 0.4) + 0.4 * Math.sin(t * 1.1) + 0.2 * Math.cos(t * 0.27);
+
+test('LeadLagCrossCorrelation detects positive lead (object output)', () => {
+  const ll = new wickra.LeadLagCrossCorrelation(12, 5);
+  let last = null;
+  // b is a delayed by 3 ⇒ a leads b ⇒ lag = +3.
+  for (let t = 0; t < 60; t++) last = ll.update(llSignal(t), llSignal(t - 3));
+  assert.equal(last.lag, 3);
+  assert.ok(last.correlation > 0.99);
+});
+
+test('LeadLagCrossCorrelation batch is flat 2*n with last row matching', () => {
+  const n = 60;
+  const a = Array.from({ length: n }, (_, t) => llSignal(t));
+  const b = Array.from({ length: n }, (_, t) => llSignal(t - 3));
+  const out = new wickra.LeadLagCrossCorrelation(12, 5).batch(a, b);
+  assert.equal(out.length, 2 * n);
+  assert.equal(out[2 * (n - 1)], 3);
+  assert.ok(out[2 * (n - 1) + 1] > 0.99);
+});
+
+test('Cointegration detects mean-reverting pair (object output)', () => {
+  const n = 80;
+  const b = Array.from({ length: n }, (_, t) => 50 + 0.5 * t);
+  const a = b.map((v, t) => 2 * v + 1 + 0.5 * Math.sin(t * 0.6));
+  const co = new wickra.Cointegration(40, 1);
+  let last = null;
+  for (let i = 0; i < n; i++) last = co.update(a[i], b[i]);
+  assert.ok(Math.abs(last.hedgeRatio - 2) < 0.1);
+  assert.ok(last.adfStat < -2);
+});
+
+test('Cointegration batch is flat 3*n with last row matching', () => {
+  const n = 80;
+  const b = Array.from({ length: n }, (_, t) => 50 + 0.5 * t);
+  const a = b.map((v, t) => 2 * v + 1 + 0.5 * Math.sin(t * 0.6));
+  const out = new wickra.Cointegration(40, 1).batch(a, b);
+  assert.equal(out.length, 3 * n);
+  assert.ok(Math.abs(out[3 * (n - 1)] - 2) < 0.1);
+  assert.ok(out[3 * (n - 1) + 2] < -2);
+});
+
+test('KalmanHedgeRatio converges to a static hedge ratio (object output)', () => {
+  const n = 500;
+  const b = Array.from({ length: n }, (_, t) => 100 + 95 * Math.sin(t * 0.5));
+  const a = b.map((v) => 2 * v + 5);
+  const k = new wickra.KalmanHedgeRatio(1e-2, 1e-3);
+  let last = null;
+  for (let i = 0; i < n; i++) last = k.update(a[i], b[i]);
+  assert.ok(Math.abs(last.hedgeRatio - 2) < 0.05);
+  assert.ok(Math.abs(last.spread) < 0.05);
+});
+
+test('KalmanHedgeRatio batch is flat 3*n with last row matching', () => {
+  const n = 500;
+  const b = Array.from({ length: n }, (_, t) => 100 + 95 * Math.sin(t * 0.5));
+  const a = b.map((v) => 2 * v + 5);
+  const out = new wickra.KalmanHedgeRatio(1e-2, 1e-3).batch(a, b);
+  assert.equal(out.length, 3 * n);
+  assert.ok(Math.abs(out[3 * (n - 1)] - 2) < 0.05);
+  assert.ok(Math.abs(out[3 * (n - 1) + 2]) < 0.05);
+});
+
+test('SpreadBollingerBands bands are ordered (object output)', () => {
+  const n = 60;
+  const b = Array.from({ length: n }, (_, t) => 100 + t);
+  const a = b.map((v, t) => v + 3 * Math.sin(t * 0.4));
+  const bb = new wickra.SpreadBollingerBands(20, 2.0);
+  let last = null;
+  for (let i = 0; i < n; i++) last = bb.update(a[i], b[i]);
+  assert.ok(last.lower <= last.middle && last.middle <= last.upper);
+});
+
+test('SpreadBollingerBands batch is flat 4*n with last row matching', () => {
+  const n = 60;
+  const b = Array.from({ length: n }, (_, t) => 100 + t);
+  const a = b.map((v, t) => v + 3 * Math.sin(t * 0.4));
+  const out = new wickra.SpreadBollingerBands(20, 2.0).batch(a, b);
+  assert.equal(out.length, 4 * n);
+  const base = 4 * (n - 1);
+  assert.ok(out[base + 2] <= out[base] && out[base] <= out[base + 1]);
+});
+
+test('RelativeStrengthAB constant ratio is flat (object output)', () => {
+  const rs = new wickra.RelativeStrengthAB(5, 5);
+  let last = null;
+  for (let i = 0; i < 30; i++) last = rs.update(200, 100); // ratio is a constant 2
+  assert.ok(Math.abs(last.ratio - 2) < 1e-12);
+  assert.ok(Math.abs(last.ratioMa - 2) < 1e-12);
+  assert.ok(Math.abs(last.ratioRsi - 50) < 1e-9);
+});
+
+test('RelativeStrengthAB batch is flat 3*n with last row matching', () => {
+  const n = 30;
+  const a = Array.from({ length: n }, () => 200);
+  const b = Array.from({ length: n }, () => 100);
+  const out = new wickra.RelativeStrengthAB(5, 5).batch(a, b);
+  assert.equal(out.length, 3 * n);
+  assert.ok(Math.abs(out[3 * (n - 1)] - 2) < 1e-12);
+  assert.ok(Math.abs(out[3 * (n - 1) + 2] - 50) < 1e-9);
+});
+
 test('SpearmanCorrelation monotone non-linear is 1', () => {
   const x = Array.from({ length: 10 }, (_, i) => i + 1);
   const y = x.map((v) => v ** 3);
@@ -815,3 +1010,506 @@ test('ALMA(3, 0.85, 6) reference value on [10, 20, 30]', () => {
   // simple mean of 20.
   assert.ok(out[2] > 20);
 });
+
+test('Doji signed mode encodes dragonfly/gravestone/neutral direction', () => {
+  // Default: direction-less detection flag (+1 doji / 0 otherwise).
+  const flag = new wickra.Doji();
+  assert.equal(flag.isSigned(), false);
+  assert.equal(flag.update(10, 11, 9, 10), 1); // body 0, range 2 -> doji
+  assert.equal(flag.update(10, 12, 10, 12), 0); // body == range -> not a doji
+
+  // Signed: classify a detected doji by its body position within the range.
+  const d = new wickra.Doji(true);
+  assert.equal(d.isSigned(), true);
+  assert.equal(d.update(10, 10.05, 6, 10), 1); // dragonfly -> bullish +1
+  assert.equal(d.update(10, 14, 9.95, 10), -1); // gravestone -> bearish -1
+  assert.equal(d.update(10, 12, 8, 10), 0); // long-legged -> neutral 0
+  assert.equal(d.update(10, 12, 10, 12), 0); // not a doji -> 0
+});
+
+test('order-book indicators reference values', () => {
+  // Top-1: (3 - 1) / (3 + 1) = 0.5.
+  assert.equal(new wickra.OrderBookImbalanceTop1().update([100], [3], [101], [1]), 0.5);
+  // Top-2: bidDepth 3, askDepth 2 -> (3 - 2) / 5 = 0.2.
+  assert.ok(
+    Math.abs(new wickra.OrderBookImbalanceTopN(2).update([100, 99], [2, 1], [101, 102], [1, 1]) - 0.2) < 1e-12,
+  );
+  // Full: bidDepth 1, askDepth 3 -> -0.5.
+  assert.equal(new wickra.OrderBookImbalanceFull().update([100], [1], [101, 102], [2, 1]), -0.5);
+  // Microprice: (100*3 + 101*1) / 4 = 100.25.
+  assert.equal(new wickra.Microprice().update([100], [1], [101], [3]), 100.25);
+  // Quoted spread: 1 / 100.5 * 10000 ≈ 99.5025 bps.
+  assert.ok(Math.abs(new wickra.QuotedSpread().update([100], [1], [101], [1]) - 99.50248756) < 1e-6);
+  // Depth slope: each side distances 1,2 -> cumulative 1,3 -> OLS slope 2.
+  assert.ok(Math.abs(new wickra.DepthSlope().update([99, 98], [1, 2], [101, 102], [1, 2]) - 2.0) < 1e-9);
+  // Single level per side -> no slope -> 0.
+  assert.equal(new wickra.DepthSlope().update([100], [1], [101], [1]), 0.0);
+});
+
+test('order-book streaming update matches batch', () => {
+  const snaps = Array.from({ length: 30 }, (_, i) => ({
+    bidPx: [100, 99],
+    bidSz: [1 + (i % 5), 1],
+    askPx: [101, 102],
+    askSz: [1 + ((i + 1) % 3), 1],
+  }));
+  const batch = new wickra.Microprice().batch(snaps);
+  const streamer = new wickra.Microprice();
+  assert.equal(batch.length, snaps.length);
+  for (let i = 0; i < snaps.length; i++) {
+    const s = streamer.update(snaps[i].bidPx, snaps[i].bidSz, snaps[i].askPx, snaps[i].askSz);
+    assert.ok(Math.abs(s - batch[i]) < 1e-12, `mismatch at ${i}: ${s} vs ${batch[i]}`);
+  }
+});
+
+test('order-book TopN rejects zero levels', () => {
+  assert.throws(() => new wickra.OrderBookImbalanceTopN(0));
+});
+
+test('order-book update rejects a crossed book', () => {
+  assert.throws(() => new wickra.QuotedSpread().update([102], [1], [101], [1]));
+});
+
+test('trade-flow indicators reference values', () => {
+  assert.equal(new wickra.SignedVolume().update(100, 2, true), 2);
+  assert.equal(new wickra.SignedVolume().update(100, 3, false), -3);
+  const cvd = new wickra.CumulativeVolumeDelta();
+  assert.equal(cvd.update(100, 5, true), 5);
+  assert.equal(cvd.update(100, 2, false), 3);
+  const ti = new wickra.TradeImbalance(2);
+  assert.equal(ti.update(100, 3, true), null); // warming up
+  assert.equal(ti.update(100, 1, false), 0.5); // (3 - 1) / 4
+});
+
+test('trade-flow streaming update matches batch', () => {
+  const n = 30;
+  const price = Array.from({ length: n }, () => 100);
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 4));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 3 !== 0);
+  const batch = new wickra.CumulativeVolumeDelta().batch(price, size, isBuy);
+  const streamer = new wickra.CumulativeVolumeDelta();
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i]);
+    assert.ok(Math.abs(s - batch[i]) < 1e-12, `mismatch at ${i}: ${s} vs ${batch[i]}`);
+  }
+});
+
+test('trade-flow rejects bad input', () => {
+  assert.throws(() => new wickra.TradeImbalance(0));
+  assert.throws(() => new wickra.SignedVolume().update(100, -1, true));
+});
+
+test('price-impact indicators reference values', () => {
+  // Buy at 100.05 vs mid 100.0: 2 * (100.05 - 100) / 100 * 10000 = 10 bps.
+  assert.ok(Math.abs(new wickra.EffectiveSpread().update(100.05, 1, true, 100.0) - 10.0) < 1e-9);
+  // Sell at 99.95 vs mid 100.0: 2 * -1 * (99.95 - 100) / 100 * 10000 = 10 bps.
+  assert.ok(Math.abs(new wickra.EffectiveSpread().update(99.95, 1, false, 100.0) - 10.0) < 1e-9);
+  // A buy filled below the mid is price improvement -> negative.
+  assert.ok(new wickra.EffectiveSpread().update(99.95, 1, true, 100.0) < 0.0);
+});
+
+test('price-impact streaming update matches batch', () => {
+  const n = 30;
+  const mid = Array.from({ length: n }, (_, i) => 100 + 0.25 * Math.sin(i * 0.5));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 3 !== 0);
+  const price = Array.from({ length: n }, (_, i) => mid[i] + (isBuy[i] ? 0.03 : -0.03));
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 4));
+  const batch = new wickra.EffectiveSpread().batch(price, size, isBuy, mid);
+  const streamer = new wickra.EffectiveSpread();
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i], mid[i]);
+    assert.ok(Math.abs(s - batch[i]) < 1e-9, `mismatch at ${i}: ${s} vs ${batch[i]}`);
+  }
+});
+
+test('realized spread resolves against the future mid', () => {
+  const rs = new wickra.RealizedSpread(1);
+  assert.equal(rs.update(100.10, 1, true, 100.0), null); // buffered
+  // 2 * (+1) * (100.10 - 100.20) / 100.0 * 10000 = -20 bps.
+  assert.ok(Math.abs(rs.update(99.90, 1, false, 100.20) - -20.0) < 1e-9);
+});
+
+test('realized spread streaming update matches batch', () => {
+  const n = 30;
+  const mid = Array.from({ length: n }, (_, i) => 100 + 0.25 * Math.sin(i * 0.5));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 3 !== 0);
+  const price = Array.from({ length: n }, (_, i) => mid[i] + (isBuy[i] ? 0.03 : -0.03));
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 4));
+  const batch = new wickra.RealizedSpread(4).batch(price, size, isBuy, mid);
+  const streamer = new wickra.RealizedSpread(4);
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i], mid[i]);
+    const got = s === null ? NaN : s;
+    assert.ok(
+      (Number.isNaN(got) && Number.isNaN(batch[i])) || Math.abs(got - batch[i]) < 1e-9,
+      `mismatch at ${i}: ${got} vs ${batch[i]}`,
+    );
+  }
+});
+
+test("kyle's lambda recovers a constant price-impact slope", () => {
+  // Each trade moves the mid by exactly 0.5 per unit of signed volume.
+  const impact = 0.5;
+  let mid = 100;
+  const price = [];
+  const size = [];
+  const isBuy = [];
+  const mids = [];
+  for (let i = 0; i < 20; i++) {
+    const buy = i % 2 === 0;
+    const sz = 1 + (i % 3);
+    const signed = buy ? sz : -sz;
+    mid += impact * signed;
+    price.push(mid);
+    size.push(sz);
+    isBuy.push(buy);
+    mids.push(mid);
+  }
+  const out = new wickra.KylesLambda(6).batch(price, size, isBuy, mids);
+  assert.ok(Math.abs(out[out.length - 1] - 0.5) < 1e-9);
+});
+
+test('price-impact rejects bad input', () => {
+  assert.throws(() => new wickra.EffectiveSpread().update(100, 1, true, 0));
+  assert.throws(() => new wickra.RealizedSpread(0));
+  assert.throws(() => new wickra.KylesLambda(1));
+});
+
+test('footprint buckets buy and sell volume per price level', () => {
+  const fp = new wickra.Footprint(1.0);
+  fp.update(100.2, 2, true); // bucket 100 -> ask 2
+  fp.update(100.7, 3, false); // bucket 101 -> bid 3
+  const out = fp.update(100.1, 1, true); // bucket 100 -> ask 3
+  assert.equal(out.length, 2);
+  assert.deepEqual(
+    { price: out[0].price, bidVol: out[0].bidVol, askVol: out[0].askVol },
+    { price: 100.0, bidVol: 0.0, askVol: 3.0 },
+  );
+  assert.deepEqual(
+    { price: out[1].price, bidVol: out[1].bidVol, askVol: out[1].askVol },
+    { price: 101.0, bidVol: 3.0, askVol: 0.0 },
+  );
+});
+
+test('footprint streaming update matches batch and rejects bad tick', () => {
+  const n = 12;
+  const price = Array.from({ length: n }, (_, i) => 100 + (i % 5) * 0.3);
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 3));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 2 === 0);
+  const batch = new wickra.Footprint(1.0).batch(price, size, isBuy);
+  const streamer = new wickra.Footprint(1.0);
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i]);
+    assert.deepEqual(s, batch[i], `mismatch at ${i}`);
+  }
+  assert.throws(() => new wickra.Footprint(0));
+});
+
+test('derivatives indicators reference values', () => {
+  // Funding rate passes through (and may be negative).
+  assert.equal(new wickra.FundingRate().update(0.0001), 0.0001);
+  assert.equal(new wickra.FundingRate().update(-0.0003), -0.0003);
+  // Rolling mean: window [0.001, 0.003] -> 0.002.
+  const frm = new wickra.FundingRateMean(2);
+  assert.equal(frm.update(0.001), null); // warming up
+  assert.ok(Math.abs(frm.update(0.003) - 0.002) < 1e-12);
+  // Z-score: window [0.001, 0.003] -> +1.
+  const z = new wickra.FundingRateZScore(2);
+  assert.equal(z.update(0.001), null); // warming up
+  assert.ok(Math.abs(z.update(0.003) - 1.0) < 1e-9);
+  // Basis: mark 100.5 vs index 100.0 -> 0.005.
+  assert.ok(Math.abs(new wickra.FundingBasis().update(100.5, 100.0) - 0.005) < 1e-12);
+  // OI delta: seeds then emits the change.
+  const oid = new wickra.OpenInterestDelta();
+  assert.equal(oid.update(1000), null);
+  assert.equal(oid.update(1250), 250);
+  assert.equal(oid.update(1100), -150);
+});
+
+test('derivatives streaming update matches batch', () => {
+  const n = 30;
+  const rate = Array.from({ length: n }, (_, i) => 0.0001 * Math.sin(i * 0.3));
+  const batch = new wickra.FundingRateMean(5).batch(rate);
+  const streamer = new wickra.FundingRateMean(5);
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(rate[i]);
+    assert.ok(
+      (s === null && Number.isNaN(batch[i])) || Math.abs(s - batch[i]) < 1e-12,
+      `mismatch at ${i}: ${s} vs ${batch[i]}`,
+    );
+  }
+});
+
+test('derivatives reject bad input', () => {
+  assert.throws(() => new wickra.FundingRateMean(0));
+  assert.throws(() => new wickra.FundingRateZScore(0));
+  assert.throws(() => new wickra.FundingBasis().update(100, 0));
+});
+
+test('market breadth: AdvanceDecline reference values', () => {
+  // A breadth tick is the universe as parallel arrays; the sign of `change`
+  // classifies each symbol as advancing / declining / unchanged.
+  const change = [
+    [1.0, 0.5, 2.0, -1.0], // 3 up, 1 down -> net +2
+    [-1.0, -0.5, -2.0, 1.0], // 1 up, 3 down -> net -2
+    [0.0, 0.0, 1.0, -1.0], // 1 up, 1 down -> net 0
+  ];
+  const volume = change.map((row) => row.map(() => 10.0));
+  const flags = change.map((row) => row.map(() => false));
+
+  const ad = new wickra.AdvanceDecline();
+  // Cumulative line: +2 -> 0 -> 0.
+  assert.equal(ad.update(change[0], volume[0], flags[0], flags[0]), 2.0);
+  assert.equal(ad.update(change[1], volume[1], flags[1], flags[1]), 0.0);
+  assert.equal(ad.update(change[2], volume[2], flags[2], flags[2]), 0.0);
+
+  // batch matches streaming.
+  const batch = new wickra.AdvanceDecline().batch(change, volume, flags, flags);
+  assert.deepEqual(Array.from(batch), [2.0, 0.0, 0.0]);
+});
+
+test('market breadth: AdvanceDecline rejects ragged universe', () => {
+  assert.throws(() =>
+    new wickra.AdvanceDecline().update(
+      [1.0, -1.0],
+      [10.0],
+      [false, false],
+      [false, false],
+    ),
+  );
+});
+
+test('market breadth: 14 indicators reference values + batch parity', () => {
+  const flags4 = [false, false, false, false];
+
+  // Advance/Decline Ratio: 3/1 = 3 ; 0 advancers -> 0.
+  const adr = new wickra.AdvanceDeclineRatio();
+  assert.equal(adr.update([1, 1, 1, -1], [10, 10, 10, 10], flags4, flags4), 3.0);
+  assert.equal(adr.update([-1, -1, -1, -1], [10, 10, 10, 10], flags4, flags4), 0.0);
+  assert.deepEqual(
+    Array.from(
+      new wickra.AdvanceDeclineRatio().batch(
+        [[1, 1, 1, -1], [-1, -1, -1, -1]],
+        [[10, 10, 10, 10], [10, 10, 10, 10]],
+        [flags4, flags4],
+        [flags4, flags4],
+      ),
+    ),
+    [3.0, 0.0],
+  );
+
+  // AD Volume Line: cumulative net advancing volume.
+  const adv = new wickra.AdVolumeLine();
+  assert.equal(adv.update([1, -1], [150, 50], [false, false], [false, false]), 100.0);
+  assert.equal(adv.update([1, -1], [60, 60], [false, false], [false, false]), 100.0);
+
+  // McClellan Oscillator + Summation: seed 0, then -50.
+  const osc = new wickra.McClellanOscillator();
+  assert.ok(Math.abs(osc.update([1, 1, 1, -1], [10, 10, 10, 10], flags4, flags4)) < 1e-9);
+  assert.ok(Math.abs(osc.update([-1, -1, -1, 1], [10, 10, 10, 10], flags4, flags4) - -50.0) < 1e-9);
+  const msi = new wickra.McClellanSummationIndex();
+  assert.ok(Math.abs(msi.update([1, 1, 1, -1], [10, 10, 10, 10], flags4, flags4)) < 1e-9);
+  assert.ok(Math.abs(msi.update([-1, -1, -1, 1], [10, 10, 10, 10], flags4, flags4) - -50.0) < 1e-9);
+
+  // TRIN: balanced breadth -> 1.
+  assert.ok(
+    Math.abs(new wickra.Trin().update([1, 1, 1, -1], [50, 50, 50, 50], flags4, flags4) - 1.0) < 1e-9,
+  );
+
+  // Breadth Thrust(2): warmup null, then SMA(2) of [0.8, 0.6] = 0.7.
+  const bt = new wickra.BreadthThrust(2);
+  const up10 = Array(10).fill(false);
+  assert.equal(bt.update([...Array(8).fill(1), -1, -1], Array(10).fill(10), up10, up10), null);
+  assert.ok(
+    Math.abs(bt.update([...Array(6).fill(1), -1, -1, -1, -1], Array(10).fill(10), up10, up10) - 0.7) < 1e-9,
+  );
+
+  // New Highs - New Lows: 2 - 1 = 1.
+  assert.equal(
+    new wickra.NewHighsNewLows().update([1, 1, -1], [10, 10, 10], [true, true, false], [false, false, true]),
+    1.0,
+  );
+
+  // High-Low Index(2): warmup null, then SMA(2) of [80, 60] = 70.
+  const hli = new wickra.HighLowIndex(2);
+  assert.equal(
+    hli.update(Array(10).fill(1), Array(10).fill(10), [...Array(8).fill(true), false, false], [...Array(8).fill(false), true, true]),
+    null,
+  );
+  assert.ok(
+    Math.abs(
+      hli.update(Array(10).fill(1), Array(10).fill(10), [...Array(6).fill(true), false, false, false, false], [...Array(6).fill(false), true, true, true, true]) - 70.0,
+    ) < 1e-9,
+  );
+
+  // Percent Above MA: 3/4 -> 75 (5-array update with aboveMa).
+  assert.equal(
+    new wickra.PercentAboveMa().update([1, 1, 1, -1], [10, 10, 10, 10], flags4, flags4, [true, true, true, false]),
+    75.0,
+  );
+
+  // Up/Down Volume Ratio: 150/50 = 3.
+  assert.equal(
+    new wickra.UpDownVolumeRatio().update([1, -1], [150, 50], [false, false], [false, false]),
+    3.0,
+  );
+
+  // Bullish Percent Index: 2/4 -> 50 (5-array update with onBuySignal).
+  assert.equal(
+    new wickra.BullishPercentIndex().update([1, 1, -1, -1], [10, 10, 10, 10], flags4, flags4, [true, true, false, false]),
+    50.0,
+  );
+
+  // Cumulative Volume Index: (100/200) -> 0.5.
+  assert.ok(
+    Math.abs(new wickra.CumulativeVolumeIndex().update([1, -1], [150, 50], [false, false], [false, false]) - 0.5) < 1e-9,
+  );
+
+  // Absolute Breadth Index: |2 - 3| = 1.
+  assert.equal(
+    new wickra.AbsoluteBreadthIndex().update([1, 1, -1, -1, -1], Array(5).fill(10), Array(5).fill(false), Array(5).fill(false)),
+    1.0,
+  );
+
+  // TICK Index: 2 - 3 = -1.
+  assert.equal(
+    new wickra.TickIndex().update([1, 1, -1, -1, -1], Array(5).fill(10), Array(5).fill(false), Array(5).fill(false)),
+    -1.0,
+  );
+});
+
+test('market breadth: rejects ragged universe', () => {
+  assert.throws(() => new wickra.Trin().update([1, -1], [10], [false, false], [false, false]));
+  assert.throws(() =>
+    new wickra.PercentAboveMa().update([1, -1], [10, 10], [false, false], [false, false], [true]),
+  );
+});
+
+test('OI / flow / liquidation indicators reference values', () => {
+  // OI +10% while price flat -> divergence +0.1.
+  const div = new wickra.OIPriceDivergence(1);
+  assert.equal(div.update(1000, 100), null); // warming up
+  assert.ok(Math.abs(div.update(1100, 100) - 0.1) < 1e-12);
+  // OI-weighted: (100·10 + 110·30) / 40 = 107.5.
+  const oiw = new wickra.OIWeighted();
+  assert.equal(oiw.update(100, 10), 100);
+  assert.ok(Math.abs(oiw.update(110, 30) - 107.5) < 1e-12);
+  // Long/short ratio.
+  assert.ok(Math.abs(new wickra.LongShortRatio().update(600, 400) - 1.5) < 1e-12);
+  assert.equal(new wickra.LongShortRatio().update(600, 0), 0);
+  // Taker buy/sell ratio.
+  assert.ok(Math.abs(new wickra.TakerBuySellRatio().update(60, 40) - 1.5) < 1e-12);
+  assert.equal(new wickra.TakerBuySellRatio().update(60, 0), 0);
+  // Liquidation features object.
+  const liq = new wickra.LiquidationFeatures().update(30, 10);
+  assert.equal(liq.net, 20);
+  assert.equal(liq.total, 40);
+  assert.equal(liq.imbalance, 0.5);
+});
+
+test('liquidation features batch is flat n*5', () => {
+  const longLiq = [10, 0, 30];
+  const shortLiq = [5, 20, 0];
+  const batch = new wickra.LiquidationFeatures().batch(longLiq, shortLiq);
+  assert.equal(batch.length, 15);
+  // Row 0: long 10, short 5, net 5, total 15.
+  assert.equal(batch[0], 10);
+  assert.equal(batch[1], 5);
+  assert.equal(batch[2], 5);
+  assert.equal(batch[3], 15);
+});
+
+test('OI flow rejects bad input', () => {
+  assert.throws(() => new wickra.OIPriceDivergence(0));
+  assert.throws(() => new wickra.OIWeighted().update(0, 100));
+});
+
+test('basis & calendar-spread reference values', () => {
+  // futures 102 vs index 100 -> 0.02 contango.
+  assert.ok(Math.abs(new wickra.TermStructureBasis().update(102, 100) - 0.02) < 1e-12);
+  assert.ok(Math.abs(new wickra.TermStructureBasis().update(98, 100) + 0.02) < 1e-12);
+  // futures 101 vs perpetual mark 100 -> 0.01.
+  assert.ok(Math.abs(new wickra.CalendarSpread().update(101, 100) - 0.01) < 1e-12);
+});
+
+test('basis streaming update matches batch', () => {
+  const n = 20;
+  const index = Array.from({ length: n }, (_, i) => 100 + Math.sin(i * 0.2));
+  const futures = Array.from({ length: n }, (_, i) => index[i] + 0.5);
+  const batch = new wickra.TermStructureBasis().batch(futures, index);
+  const streamer = new wickra.TermStructureBasis();
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    assert.ok(Math.abs(streamer.update(futures[i], index[i]) - batch[i]) < 1e-12);
+  }
+});
+
+test('basis rejects bad input', () => {
+  assert.throws(() => new wickra.TermStructureBasis().update(100, 0));
+  assert.throws(() => new wickra.CalendarSpread().update(100, 0));
+});
+
+test('VolumeProfile exposes the full histogram', () => {
+  // bar0 single-print at 10 vol 100; bar1 spans 10..14 vol 80 over 4 bins.
+  const vp = new wickra.VolumeProfile(2, 4);
+  assert.equal(vp.update(10, 10, 100), null);
+  const out = vp.update(14, 10, 80);
+  assert.ok(out !== null);
+  assert.ok(Math.abs(out.priceLow - 10) < 1e-9);
+  assert.ok(Math.abs(out.priceHigh - 14) < 1e-9);
+  assert.deepEqual(out.bins.length, 4);
+  assert.ok(Math.abs(out.bins[0] - 120) < 1e-9);
+  for (let i = 1; i < 4; i++) {
+    assert.ok(Math.abs(out.bins[i] - 20) < 1e-9);
+  }
+});
+
+test('TpoProfile counts time at price, volume-agnostic', () => {
+  // bar0 spans 10..14 (+1 each bin); bar1 spans 11..12 (+1 bins 1,2).
+  const tpo = new wickra.TpoProfile(2, 4);
+  assert.equal(tpo.update(14, 10), null);
+  const out = tpo.update(12, 11);
+  assert.ok(out !== null);
+  assert.ok(Math.abs(out.priceLow - 10) < 1e-9);
+  assert.ok(Math.abs(out.priceHigh - 14) < 1e-9);
+  assert.deepEqual(out.counts, [1, 2, 2, 1]);
+});
+
+test('RenkoBars prints aligned bricks and reverses on two boxes', () => {
+  const r = new wickra.RenkoBars(1.0);
+  assert.deepEqual(r.update(10), []); // seed
+  const up = r.update(13);
+  assert.equal(up.length, 3);
+  assert.ok(Math.abs(up[0].open - 10) < 1e-9 && Math.abs(up[0].close - 11) < 1e-9);
+  assert.ok(up.every((b) => b.direction === 1));
+  const down = r.update(10);
+  assert.equal(down.length, 2);
+  assert.ok(down.every((b) => b.direction === -1));
+});
+
+test('KagiBars closes a segment on a reversal', () => {
+  const k = new wickra.KagiBars(2.0);
+  k.update(10);
+  k.update(11);
+  k.update(15);
+  const seg = k.update(12);
+  assert.equal(seg.length, 1);
+  assert.equal(seg[0].direction, 1);
+  assert.ok(Math.abs(seg[0].start - 10) < 1e-9 && Math.abs(seg[0].end - 15) < 1e-9);
+});
+
+test('PointAndFigureBars closes a column on a 3-box reversal', () => {
+  const pnf = new wickra.PointAndFigureBars(1.0, 3);
+  pnf.update(10);
+  pnf.update(13);
+  pnf.update(15);
+  const col = pnf.update(12);
+  assert.equal(col.length, 1);
+  assert.equal(col[0].direction, 1);
+  assert.ok(Math.abs(col[0].high - 15) < 1e-9 && Math.abs(col[0].low - 10) < 1e-9);
+});

bindings/node/__tests__/seasonality.test.js

@@ -0,0 +1,96 @@
+// Streaming-vs-batch equivalence and reference values for the Seasonality &
+// Session family. These indicators consume the full candle (open, high, low,
+// close, volume, timestamp), so they have a dedicated suite.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const wickra = require('..');
+
+const HOUR = 3_600_000;
+const N = 240;
+const close = Array.from({ length: N }, (_, i) => 100 + Math.sin(i * 0.3) * 5 + Math.cos(i * 0.1) * 3);
+const open = close.map((c, i) => c + Math.sin(i * 0.5) * 0.5);
+const high = close.map((c, i) => Math.max(open[i], c) + 1);
+const low = close.map((c, i) => Math.min(open[i], c) - 1);
+const volume = Array.from({ length: N }, (_, i) => 1000 + (i % 24) * 50);
+const ts = Array.from({ length: N }, (_, i) => i * HOUR);
+
+function eq(a, b) {
+  if (Number.isNaN(a)) return Number.isNaN(b);
+  return Math.abs(a - b) < 1e-9;
+}
+
+function streamScalar(ind, i) {
+  const v = ind.update(open[i], high[i], low[i], close[i], volume[i], ts[i]);
+  return v === null || v === undefined ? NaN : v;
+}
+
+function checkScalar(name, make) {
+  test(`${name} streaming equals batch`, () => {
+    const a = make();
+    const b = make();
+    const batch = b.batch(open, high, low, close, volume, ts);
+    for (let i = 0; i < N; i += 1) {
+      assert.ok(eq(streamScalar(a, i), batch[i]), `${name} row ${i}`);
+    }
+  });
+}
+
+function checkMatrix(name, make, k, pick) {
+  test(`${name} streaming equals batch`, () => {
+    const a = make();
+    const b = make();
+    const batch = b.batch(open, high, low, close, volume, ts);
+    for (let i = 0; i < N; i += 1) {
+      const out = a.update(open[i], high[i], low[i], close[i], volume[i], ts[i]);
+      for (let j = 0; j < k; j += 1) {
+        const s = out === null || out === undefined ? NaN : pick(out, j);
+        assert.ok(eq(s, batch[i * k + j]), `${name} row ${i} col ${j}`);
+      }
+    }
+  });
+}
+
+checkScalar('SessionVwap', () => new wickra.SessionVwap(0));
+checkScalar('OvernightGap', () => new wickra.OvernightGap(0));
+checkScalar('SeasonalZScore', () => new wickra.SeasonalZScore(0));
+checkScalar('AverageDailyRange', () => new wickra.AverageDailyRange(3, 0));
+checkScalar('TurnOfMonth', () => new wickra.TurnOfMonth(3, 1, 0));
+
+checkMatrix('SessionHighLow', () => new wickra.SessionHighLow(0), 2, (o, j) => (j === 0 ? o.high : o.low));
+checkMatrix('SessionRange', () => new wickra.SessionRange(0), 3, (o, j) => [o.asia, o.eu, o.us][j]);
+checkMatrix(
+  'OvernightIntradayReturn',
+  () => new wickra.OvernightIntradayReturn(0),
+  2,
+  (o, j) => (j === 0 ? o.overnight : o.intraday),
+);
+checkMatrix('TimeOfDayReturnProfile', () => new wickra.TimeOfDayReturnProfile(24, 0), 24, (o, j) => o[j]);
+checkMatrix('IntradayVolatilityProfile', () => new wickra.IntradayVolatilityProfile(12, 0), 12, (o, j) => o[j]);
+checkMatrix('VolumeByTimeProfile', () => new wickra.VolumeByTimeProfile(24, 0), 24, (o, j) => o[j]);
+checkMatrix('DayOfWeekProfile', () => new wickra.DayOfWeekProfile(0), 7, (o, j) => o[j]);
+
+test('SessionVwap reference value', () => {
+  const vwap = new wickra.SessionVwap(0);
+  assert.ok(eq(vwap.update(100, 100, 100, 100, 10, 0), 100));
+  assert.ok(eq(vwap.update(110, 110, 110, 110, 30, HOUR), 107.5));
+  assert.ok(eq(vwap.update(200, 200, 200, 200, 5, 24 * HOUR), 200));
+});
+
+test('OvernightGap reference value', () => {
+  const gap = new wickra.OvernightGap(0);
+  assert.equal(gap.update(99, 101, 98, 100, 1, 0), null);
+  assert.ok(eq(gap.update(105, 106, 104, 105.5, 1, 24 * HOUR), 0.05));
+});
+
+test('SessionHighLow reference object', () => {
+  const shl = new wickra.SessionHighLow(0);
+  shl.update(100, 105, 99, 101, 1, 0);
+  const out = shl.update(101, 108, 100, 107, 1, HOUR);
+  assert.ok(eq(out.high, 108));
+  assert.ok(eq(out.low, 99));
+});
+
+test('AverageDailyRange rejects zero period', () => {
+  assert.throws(() => new wickra.AverageDailyRange(0, 0));
+});

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, ADXR, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, KAMA, RVI, PGO, KST, SMI, LaguerreRSI, ConnorsRSI, Inertia, ALMA, McGinleyDynamic, FRAMA, VIDYA, JMA, Alligator, EVWMA, APO, AwesomeOscillatorHistogram, CFO, ZeroLagMACD, ElderImpulse, STC, T3, TSI, PMO, TII, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, EaseOfMovement, KVO, VolumeOscillator, NVI, PVI, WilliamsAD, AnchoredVWAP, DemandIndex, TSV, VZO, MarketFacilitationIndex, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, HiLoActivator, VoltyStop, YoyoExit, DonchianStop, PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, Vortex, RWI, WaveTrend, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA, RVIVolatility, ParkinsonVolatility, GarmanKlassVolatility, RogersSatchellVolatility, YangZhangVolatility, 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, SuperSmoother, FisherTransform, InverseFisherTransform, Decycler, DecyclerOscillator, RoofingFilter, CenterOfGravity, CyberneticCycle, InstantaneousTrendline, EhlersStochastic, EmpiricalModeDecomposition, HilbertDominantCycle, AdaptiveCycle, SineWave, MAMA, FAMA, Ichimoku, HeikinAshi, Variance, CoefficientOfVariation, Skewness, Kurtosis, StandardError, DetrendedStdDev, RSquared, MedianAbsoluteDeviation, Autocorrelation, HurstExponent, PearsonCorrelation, Beta, SpearmanCorrelation, ValueArea, InitialBalance, OpeningRange, Doji, Hammer, InvertedHammer, HangingMan, ShootingStar, Engulfing, Harami, MorningEveningStar, ThreeSoldiersOrCrows, PiercingDarkCloud, Marubozu, Tweezer, SpinningTop, ThreeInside, ThreeOutside, SharpeRatio, SortinoRatio, CalmarRatio, OmegaRatio, MaxDrawdown, AverageDrawdown, DrawdownDuration, PainIndex, ValueAtRisk, ConditionalValueAtRisk, ProfitFactor, GainLossRatio, RecoveryFactor, KellyCriterion, TreynorRatio, InformationRatio, Alpha } = 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, MIDPOINT, ROCP, ROCR, ROCR100, LINEARREG_INTERCEPT, TSF, Autocorrelation, HurstExponent, PearsonCorrelation, Beta, PairwiseBeta, SpearmanCorrelation, RollingCorrelation, RollingCovariance, OuHalfLife, SpreadHurst, DistanceSsd, BetaNeutralSpread, PairSpreadZScore, LeadLagCrossCorrelation, Cointegration, RelativeStrengthAB, VarianceRatio, GrangerCausality, KalmanHedgeRatio, SpreadBollingerBands, MACD, MACDFIX, MACDEXT, BollingerBands, ATR, PLUS_DM, MINUS_DM, PLUS_DI, MINUS_DI, DX, MIDPRICE, AVGPRICE, SAREXT, HT_PHASOR, 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, AnchoredRSI, 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, HT_DCPHASE, HT_TRENDMODE, HilbertDominantCycle, AdaptiveCycle, SineWave, MAMA, FAMA, Ichimoku, HeikinAshi, ValueArea, VolumeProfile, TpoProfile, 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, AdvanceDecline, AdvanceDeclineRatio, AdVolumeLine, McClellanOscillator, McClellanSummationIndex, Trin, BreadthThrust, NewHighsNewLows, HighLowIndex, PercentAboveMa, UpDownVolumeRatio, BullishPercentIndex, CumulativeVolumeIndex, AbsoluteBreadthIndex, TickIndex, SharpeRatio, SortinoRatio, CalmarRatio, OmegaRatio, MaxDrawdown, AverageDrawdown, DrawdownDuration, PainIndex, ValueAtRisk, ConditionalValueAtRisk, ProfitFactor, GainLossRatio, RecoveryFactor, KellyCriterion, TreynorRatio, InformationRatio, RenkoBars, KagiBars, PointAndFigureBars, Alpha, SessionVwap, OvernightGap, SeasonalZScore, TimeOfDayReturnProfile, IntradayVolatilityProfile, VolumeByTimeProfile, DayOfWeekProfile, AverageDailyRange, TurnOfMonth, SessionHighLow, SessionRange, OvernightIntradayReturn } = nativeBinding
 
 module.exports.version = version
 module.exports.SMA = SMA
@@ -332,9 +332,64 @@ 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.MIDPOINT = MIDPOINT
+module.exports.ROCP = ROCP
+module.exports.ROCR = ROCR
+module.exports.ROCR100 = ROCR100
+module.exports.LINEARREG_INTERCEPT = LINEARREG_INTERCEPT
+module.exports.TSF = TSF
+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.RollingCorrelation = RollingCorrelation
+module.exports.RollingCovariance = RollingCovariance
+module.exports.OuHalfLife = OuHalfLife
+module.exports.SpreadHurst = SpreadHurst
+module.exports.DistanceSsd = DistanceSsd
+module.exports.BetaNeutralSpread = BetaNeutralSpread
+module.exports.PairSpreadZScore = PairSpreadZScore
+module.exports.LeadLagCrossCorrelation = LeadLagCrossCorrelation
+module.exports.Cointegration = Cointegration
+module.exports.RelativeStrengthAB = RelativeStrengthAB
+module.exports.VarianceRatio = VarianceRatio
+module.exports.GrangerCausality = GrangerCausality
+module.exports.KalmanHedgeRatio = KalmanHedgeRatio
+module.exports.SpreadBollingerBands = SpreadBollingerBands
 module.exports.MACD = MACD
+module.exports.MACDFIX = MACDFIX
+module.exports.MACDEXT = MACDEXT
 module.exports.BollingerBands = BollingerBands
 module.exports.ATR = ATR
+module.exports.PLUS_DM = PLUS_DM
+module.exports.MINUS_DM = MINUS_DM
+module.exports.PLUS_DI = PLUS_DI
+module.exports.MINUS_DI = MINUS_DI
+module.exports.DX = DX
+module.exports.MIDPRICE = MIDPRICE
+module.exports.AVGPRICE = AVGPRICE
+module.exports.SAREXT = SAREXT
+module.exports.HT_PHASOR = HT_PHASOR
 module.exports.Stochastic = Stochastic
 module.exports.OBV = OBV
 module.exports.ADX = ADX
@@ -349,27 +404,25 @@ module.exports.VWAP = VWAP
 module.exports.RollingVWAP = RollingVWAP
 module.exports.AwesomeOscillator = AwesomeOscillator
 module.exports.Aroon = Aroon
-module.exports.KAMA = KAMA
-module.exports.RVI = RVI
-module.exports.PGO = PGO
-module.exports.KST = KST
-module.exports.SMI = SMI
-module.exports.LaguerreRSI = LaguerreRSI
-module.exports.ConnorsRSI = ConnorsRSI
 module.exports.Inertia = Inertia
-module.exports.ALMA = ALMA
-module.exports.McGinleyDynamic = McGinleyDynamic
-module.exports.FRAMA = FRAMA
-module.exports.VIDYA = VIDYA
-module.exports.JMA = JMA
-module.exports.Alligator = Alligator
-module.exports.EVWMA = EVWMA
-module.exports.APO = APO
+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.CFO = CFO
-module.exports.ZeroLagMACD = ZeroLagMACD
-module.exports.ElderImpulse = ElderImpulse
 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
@@ -379,17 +432,18 @@ module.exports.VolumePriceTrend = VolumePriceTrend
 module.exports.ChaikinMoneyFlow = ChaikinMoneyFlow
 module.exports.ChaikinOscillator = ChaikinOscillator
 module.exports.ForceIndex = ForceIndex
-module.exports.EaseOfMovement = EaseOfMovement
-module.exports.KVO = KVO
-module.exports.VolumeOscillator = VolumeOscillator
 module.exports.NVI = NVI
 module.exports.PVI = PVI
+module.exports.VolumeOscillator = VolumeOscillator
+module.exports.KVO = KVO
 module.exports.WilliamsAD = WilliamsAD
+module.exports.AnchoredRSI = AnchoredRSI
 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
@@ -411,26 +465,25 @@ 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.Vortex = Vortex
-module.exports.RWI = RWI
 module.exports.WaveTrend = WaveTrend
+module.exports.RWI = RWI
+module.exports.Vortex = Vortex
 module.exports.MassIndex = MassIndex
 module.exports.StochRSI = StochRSI
 module.exports.UltimateOscillator = UltimateOscillator
 module.exports.PPO = PPO
 module.exports.Coppock = Coppock
 module.exports.VWMA = VWMA
-module.exports.RVIVolatility = RVIVolatility
-module.exports.ParkinsonVolatility = ParkinsonVolatility
-module.exports.GarmanKlassVolatility = GarmanKlassVolatility
-module.exports.RogersSatchellVolatility = RogersSatchellVolatility
-module.exports.YangZhangVolatility = YangZhangVolatility
 module.exports.MaEnvelope = MaEnvelope
 module.exports.AccelerationBands = AccelerationBands
 module.exports.StarcBands = StarcBands
@@ -461,17 +514,12 @@ module.exports.TDRangeProjection = TDRangeProjection
 module.exports.TDDifferential = TDDifferential
 module.exports.TDOpen = TDOpen
 module.exports.TDRiskLevel = TDRiskLevel
-module.exports.SuperSmoother = SuperSmoother
-module.exports.FisherTransform = FisherTransform
 module.exports.InverseFisherTransform = InverseFisherTransform
-module.exports.Decycler = Decycler
 module.exports.DecyclerOscillator = DecyclerOscillator
 module.exports.RoofingFilter = RoofingFilter
-module.exports.CenterOfGravity = CenterOfGravity
-module.exports.CyberneticCycle = CyberneticCycle
-module.exports.InstantaneousTrendline = InstantaneousTrendline
-module.exports.EhlersStochastic = EhlersStochastic
 module.exports.EmpiricalModeDecomposition = EmpiricalModeDecomposition
+module.exports.HT_DCPHASE = HT_DCPHASE
+module.exports.HT_TRENDMODE = HT_TRENDMODE
 module.exports.HilbertDominantCycle = HilbertDominantCycle
 module.exports.AdaptiveCycle = AdaptiveCycle
 module.exports.SineWave = SineWave
@@ -479,20 +527,9 @@ module.exports.MAMA = MAMA
 module.exports.FAMA = FAMA
 module.exports.Ichimoku = Ichimoku
 module.exports.HeikinAshi = HeikinAshi
-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.SpearmanCorrelation = SpearmanCorrelation
 module.exports.ValueArea = ValueArea
+module.exports.VolumeProfile = VolumeProfile
+module.exports.TpoProfile = TpoProfile
 module.exports.InitialBalance = InitialBalance
 module.exports.OpeningRange = OpeningRange
 module.exports.Doji = Doji
@@ -510,7 +547,91 @@ module.exports.Tweezer = Tweezer
 module.exports.SpinningTop = SpinningTop
 module.exports.ThreeInside = ThreeInside
 module.exports.ThreeOutside = ThreeOutside
-// Family 15: Risk / Performance metrics
+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.AdvanceDecline = AdvanceDecline
+module.exports.AdvanceDeclineRatio = AdvanceDeclineRatio
+module.exports.AdVolumeLine = AdVolumeLine
+module.exports.McClellanOscillator = McClellanOscillator
+module.exports.McClellanSummationIndex = McClellanSummationIndex
+module.exports.Trin = Trin
+module.exports.BreadthThrust = BreadthThrust
+module.exports.NewHighsNewLows = NewHighsNewLows
+module.exports.HighLowIndex = HighLowIndex
+module.exports.PercentAboveMa = PercentAboveMa
+module.exports.UpDownVolumeRatio = UpDownVolumeRatio
+module.exports.BullishPercentIndex = BullishPercentIndex
+module.exports.CumulativeVolumeIndex = CumulativeVolumeIndex
+module.exports.AbsoluteBreadthIndex = AbsoluteBreadthIndex
+module.exports.TickIndex = TickIndex
 module.exports.SharpeRatio = SharpeRatio
 module.exports.SortinoRatio = SortinoRatio
 module.exports.CalmarRatio = CalmarRatio
@@ -527,4 +648,19 @@ module.exports.RecoveryFactor = RecoveryFactor
 module.exports.KellyCriterion = KellyCriterion
 module.exports.TreynorRatio = TreynorRatio
 module.exports.InformationRatio = InformationRatio
+module.exports.RenkoBars = RenkoBars
+module.exports.KagiBars = KagiBars
+module.exports.PointAndFigureBars = PointAndFigureBars
 module.exports.Alpha = Alpha
+module.exports.SessionVwap = SessionVwap
+module.exports.OvernightGap = OvernightGap
+module.exports.SeasonalZScore = SeasonalZScore
+module.exports.TimeOfDayReturnProfile = TimeOfDayReturnProfile
+module.exports.IntradayVolatilityProfile = IntradayVolatilityProfile
+module.exports.VolumeByTimeProfile = VolumeByTimeProfile
+module.exports.DayOfWeekProfile = DayOfWeekProfile
+module.exports.AverageDailyRange = AverageDailyRange
+module.exports.TurnOfMonth = TurnOfMonth
+module.exports.SessionHighLow = SessionHighLow
+module.exports.SessionRange = SessionRange
+module.exports.OvernightIntradayReturn = OvernightIntradayReturn

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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-darwin-arm64",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": "MIT OR Apache-2.0",
   "engines": {
     "node": ">= 18"
   },

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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-darwin-x64",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": "MIT OR Apache-2.0",
   "engines": {
     "node": ">= 18"
   },

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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-linux-arm64-gnu",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": "MIT OR Apache-2.0",
   "engines": {
     "node": ">= 18"
   },

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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-linux-x64-gnu",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": "MIT OR Apache-2.0",
   "engines": {
     "node": ">= 18"
   },

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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-win32-arm64-msvc",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": "MIT OR Apache-2.0",
   "engines": {
     "node": ">= 18"
   },

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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-win32-x64-msvc",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": "MIT OR Apache-2.0",
   "engines": {
     "node": ">= 18"
   },

bindings/node/package-lock.json

@@ -1,13 +1,13 @@
 {
   "name": "wickra",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "wickra",
-      "version": "0.4.0",
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "version": "0.5.1",
+      "license": "MIT OR Apache-2.0",
       "devDependencies": {
         "@napi-rs/cli": "^2.18.0"
       },
@@ -15,12 +15,12 @@
         "node": ">= 18"
       },
       "optionalDependencies": {
-        "wickra-darwin-arm64": "0.4.0",
-        "wickra-darwin-x64": "0.4.0",
-        "wickra-linux-arm64-gnu": "0.4.0",
-        "wickra-linux-x64-gnu": "0.4.0",
-        "wickra-win32-arm64-msvc": "0.4.0",
-        "wickra-win32-x64-msvc": "0.4.0"
+        "wickra-darwin-arm64": "0.5.1",
+        "wickra-darwin-x64": "0.5.1",
+        "wickra-linux-arm64-gnu": "0.5.1",
+        "wickra-linux-x64-gnu": "0.5.1",
+        "wickra-win32-arm64-msvc": "0.5.1",
+        "wickra-win32-x64-msvc": "0.5.1"
       }
     },
     "node_modules/@napi-rs/cli": {
@@ -41,13 +41,13 @@
       }
     },
     "node_modules/wickra-darwin-arm64": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.4.0.tgz",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.5.1.tgz",
       "integrity": "sha512-4eZiBR/yGUdr4nzhEUFy2i69XgNx64iI2ax/LPamsThgylC0KpHOZKK19QzJ2d9KbK4C8nMjME5FLuR+4GNEwQ==",
       "cpu": [
         "arm64"
       ],
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "darwin"
@@ -57,13 +57,13 @@
       }
     },
     "node_modules/wickra-darwin-x64": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.4.0.tgz",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.5.1.tgz",
       "integrity": "sha512-6hf8zI3QPjTFp4zCpmgUwDvNtu6jHqNUHKD5e55POo0CgA52HkpyxSPtVm8TGTIZDI7kPjlbOdBM8CJ76mmXwA==",
       "cpu": [
         "x64"
       ],
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "darwin"
@@ -73,13 +73,13 @@
       }
     },
     "node_modules/wickra-linux-arm64-gnu": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.4.0.tgz",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.5.1.tgz",
       "integrity": "sha512-kSe6y0xBMSiqdPLXNjwop5WZdHtvdBNKSEBCwZ4hFq33p4apW25/wrlzv9/oDuyD4kuPabJEhCCnFOplh58CUg==",
       "cpu": [
         "arm64"
       ],
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "linux"
@@ -89,13 +89,13 @@
       }
     },
     "node_modules/wickra-linux-x64-gnu": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.4.0.tgz",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.5.1.tgz",
       "integrity": "sha512-tWBWS4qz7hxM4xnpFb59bhf6TaLwXq0Z3jEa/2l7r8PiHA94g8r8S53NRMiT+4yiL5hSWe/nUiC/YXdRrhEZ4g==",
       "cpu": [
         "x64"
       ],
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "linux"
@@ -105,13 +105,13 @@
       }
     },
     "node_modules/wickra-win32-arm64-msvc": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.4.0.tgz",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.5.1.tgz",
       "integrity": "sha512-EXIckHxAtF75PUGDKRzXyqMe9ldP0JjSdu68WFN6iJfp+McYrGu6h40TEJlQ/oUEIoPqiZB/xhVyo/el5Lg7zw==",
       "cpu": [
         "arm64"
       ],
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "win32"
@@ -121,13 +121,13 @@
       }
     },
     "node_modules/wickra-win32-x64-msvc": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.4.0.tgz",
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.5.1.tgz",
       "integrity": "sha512-Yfsqq1Xwp6hdxMyLze411vNdo7BDwI6+lPSe7A9XdqyPecNDbtKwYLpsal2r8EHbNzqM+R8XnuRtUaEQS5VlUQ==",
       "cpu": [
         "x64"
       ],
-      "license": "PolyForm-Noncommercial-1.0.0",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "win32"

bindings/node/package.json

@@ -1,11 +1,11 @@
 {
   "name": "wickra",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Streaming-first technical indicators: incremental, fast, install-free. Node bindings powered by Rust.",
   "author": "kingchenc <support@wickra.org>",
   "main": "index.js",
   "types": "index.d.ts",
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "MIT OR Apache-2.0",
   "keywords": [
     "trading",
     "indicators",
@@ -47,12 +47,12 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "wickra-linux-x64-gnu": "0.4.0",
-    "wickra-linux-arm64-gnu": "0.4.0",
-    "wickra-darwin-x64": "0.4.0",
-    "wickra-darwin-arm64": "0.4.0",
-    "wickra-win32-x64-msvc": "0.4.0",
-    "wickra-win32-arm64-msvc": "0.4.0"
+    "wickra-linux-x64-gnu": "0.5.1",
+    "wickra-linux-arm64-gnu": "0.5.1",
+    "wickra-darwin-x64": "0.5.1",
+    "wickra-darwin-arm64": "0.5.1",
+    "wickra-win32-x64-msvc": "0.5.1",
+    "wickra-win32-arm64-msvc": "0.5.1"
   },
   "scripts": {
     "build": "napi build --platform --release",

bindings/python/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
 [![PyPI](https://img.shields.io/pypi/v/wickra.svg?logo=pypi&color=blue)](https://pypi.org/project/wickra/)
-[![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](https://github.com/wickra-lib/wickra/blob/main/LICENSE)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
 
 **Streaming-first technical indicators for Python. `pip install wickra` — no
 system dependencies, no C build tooling.**
@@ -66,7 +66,5 @@ risk. The library is provided **as is**, without warranty of any kind.
 
 ## License
 
-Licensed under the **PolyForm Noncommercial License 1.0.0**. Personal projects,
-research, education, non-profits, and hobby trading bots are all fine; the one
-thing not allowed is commercial sale of the software or of services built
-around it. See [LICENSE](https://github.com/wickra-lib/wickra/blob/main/LICENSE).
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/python/pyproject.toml

@@ -4,17 +4,16 @@ build-backend = "maturin"
 
 [project]
 name = "wickra"
-version = "0.4.0"
+version = "0.5.1"
 description = "Streaming-first technical indicators: incremental, fast, install-free."
 readme = "README.md"
-license = { text = "PolyForm-Noncommercial-1.0.0" }
+license = "MIT OR Apache-2.0"
 authors = [{ name = "kingchenc", email = "support@wickra.org" }]
 requires-python = ">=3.9"
 keywords = ["finance", "trading", "indicators", "technical-analysis", "ta-lib"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Financial and Insurance Industry",
-    "License :: Free for non-commercial use",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3.9",

bindings/python/python/wickra/__init__.py

@@ -25,6 +25,17 @@ from __future__ import annotations
 
 from ._wickra import (
     __version__,
+    TSF,
+    LINEARREG_INTERCEPT,
+    ROCR100,
+    ROCR,
+    ROCP,
+    AVGPRICE,
+    MIDPOINT,
+    MIDPRICE,
+    DX,
+    MINUS_DI,
+    PLUS_DI,
     # Trend
     SMA,
     EMA,
@@ -47,13 +58,18 @@ from ._wickra import (
     EVWMA,
     # Momentum
     RSI,
+    AnchoredRSI,
     MACD,
+    MACDFIX,
+    MACDEXT,
     Stochastic,
     CCI,
     ROC,
     WilliamsR,
     ADX,
     ADXR,
+    PLUS_DM,
+    MINUS_DM,
     MFI,
     TRIX,
     AwesomeOscillator,
@@ -97,6 +113,7 @@ from ._wickra import (
     Keltner,
     Donchian,
     PSAR,
+    SAREXT,
     NATR,
     StdDev,
     UlcerIndex,
@@ -142,6 +159,16 @@ from ._wickra import (
     MarketFacilitationIndex,
     EaseOfMovement,
     # Statistics
+    SpreadBollingerBands,
+    KalmanHedgeRatio,
+    GrangerCausality,
+    VarianceRatio,
+    BetaNeutralSpread,
+    DistanceSsd,
+    SpreadHurst,
+    OuHalfLife,
+    RollingCovariance,
+    RollingCorrelation,
     TypicalPrice,
     MedianPrice,
     WeightedClose,
@@ -161,6 +188,11 @@ from ._wickra import (
     HurstExponent,
     PearsonCorrelation,
     Beta,
+    PairwiseBeta,
+    PairSpreadZScore,
+    LeadLagCrossCorrelation,
+    Cointegration,
+    RelativeStrengthAB,
     SpearmanCorrelation,
     # Ehlers / Cycle
     SuperSmoother,
@@ -175,6 +207,9 @@ from ._wickra import (
     EhlersStochastic,
     EmpiricalModeDecomposition,
     HilbertDominantCycle,
+    HT_DCPHASE,
+    HT_PHASOR,
+    HT_TRENDMODE,
     AdaptiveCycle,
     SineWave,
     MAMA,
@@ -217,8 +252,14 @@ from ._wickra import (
     HeikinAshi,
     # Market Profile
     ValueArea,
+    VolumeProfile,
+    TpoProfile,
     InitialBalance,
     OpeningRange,
+    # Alt-Chart Bars
+    RenkoBars,
+    KagiBars,
+    PointAndFigureBars,
     # Candlestick patterns
     Doji,
     Hammer,
@@ -235,6 +276,97 @@ from ._wickra import (
     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,
+    # Market Breadth
+    TickIndex,
+    AbsoluteBreadthIndex,
+    CumulativeVolumeIndex,
+    BullishPercentIndex,
+    UpDownVolumeRatio,
+    PercentAboveMa,
+    HighLowIndex,
+    NewHighsNewLows,
+    BreadthThrust,
+    Trin,
+    McClellanSummationIndex,
+    McClellanOscillator,
+    AdVolumeLine,
+    AdvanceDeclineRatio,
+    AdvanceDecline,
     # Risk / Performance
     SharpeRatio,
     SortinoRatio,
@@ -253,9 +385,33 @@ from ._wickra import (
     TreynorRatio,
     InformationRatio,
     Alpha,
+    # Seasonality & Session
+    SessionVwap,
+    SessionHighLow,
+    SessionRange,
+    AverageDailyRange,
+    OvernightGap,
+    OvernightIntradayReturn,
+    TurnOfMonth,
+    SeasonalZScore,
+    TimeOfDayReturnProfile,
+    DayOfWeekProfile,
+    IntradayVolatilityProfile,
+    VolumeByTimeProfile,
 )
 
 __all__ = [
+    "TSF",
+    "LINEARREG_INTERCEPT",
+    "ROCR100",
+    "ROCR",
+    "ROCP",
+    "AVGPRICE",
+    "MIDPOINT",
+    "MIDPRICE",
+    "DX",
+    "MINUS_DI",
+    "PLUS_DI",
     "__version__",
     # Trend
     "SMA",
@@ -279,13 +435,18 @@ __all__ = [
     "EVWMA",
     # Momentum
     "RSI",
+    "AnchoredRSI",
     "MACD",
+    "MACDFIX",
+    "MACDEXT",
     "Stochastic",
     "CCI",
     "ROC",
     "WilliamsR",
     "ADX",
     "ADXR",
+    "PLUS_DM",
+    "MINUS_DM",
     "MFI",
     "TRIX",
     "AwesomeOscillator",
@@ -329,6 +490,7 @@ __all__ = [
     "Keltner",
     "Donchian",
     "PSAR",
+    "SAREXT",
     "NATR",
     "StdDev",
     "UlcerIndex",
@@ -374,6 +536,16 @@ __all__ = [
     "MarketFacilitationIndex",
     "EaseOfMovement",
     # Statistics
+    "SpreadBollingerBands",
+    "KalmanHedgeRatio",
+    "GrangerCausality",
+    "VarianceRatio",
+    "BetaNeutralSpread",
+    "DistanceSsd",
+    "SpreadHurst",
+    "OuHalfLife",
+    "RollingCovariance",
+    "RollingCorrelation",
     "TypicalPrice",
     "MedianPrice",
     "WeightedClose",
@@ -393,6 +565,11 @@ __all__ = [
     "HurstExponent",
     "PearsonCorrelation",
     "Beta",
+    "PairwiseBeta",
+    "PairSpreadZScore",
+    "LeadLagCrossCorrelation",
+    "Cointegration",
+    "RelativeStrengthAB",
     "SpearmanCorrelation",
     # Ehlers / Cycle
     "SuperSmoother",
@@ -407,6 +584,9 @@ __all__ = [
     "EhlersStochastic",
     "EmpiricalModeDecomposition",
     "HilbertDominantCycle",
+    "HT_DCPHASE",
+    "HT_PHASOR",
+    "HT_TRENDMODE",
     "AdaptiveCycle",
     "SineWave",
     "MAMA",
@@ -449,8 +629,14 @@ __all__ = [
     "HeikinAshi",
     # Market Profile
     "ValueArea",
+    "VolumeProfile",
+    "TpoProfile",
     "InitialBalance",
     "OpeningRange",
+    # Alt-Chart Bars
+    "RenkoBars",
+    "KagiBars",
+    "PointAndFigureBars",
     # Candlestick patterns
     "Doji",
     "Hammer",
@@ -467,6 +653,97 @@ __all__ = [
     "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",
+    # Market Breadth
+    "TickIndex",
+    "AbsoluteBreadthIndex",
+    "CumulativeVolumeIndex",
+    "BullishPercentIndex",
+    "UpDownVolumeRatio",
+    "PercentAboveMa",
+    "HighLowIndex",
+    "NewHighsNewLows",
+    "BreadthThrust",
+    "Trin",
+    "McClellanSummationIndex",
+    "McClellanOscillator",
+    "AdVolumeLine",
+    "AdvanceDeclineRatio",
+    "AdvanceDecline",
     # Risk / Performance
     "SharpeRatio",
     "SortinoRatio",
@@ -485,4 +762,17 @@ __all__ = [
     "TreynorRatio",
     "InformationRatio",
     "Alpha",
+    # Seasonality & Session
+    "SessionVwap",
+    "SessionHighLow",
+    "SessionRange",
+    "AverageDailyRange",
+    "OvernightGap",
+    "OvernightIntradayReturn",
+    "TurnOfMonth",
+    "SeasonalZScore",
+    "TimeOfDayReturnProfile",
+    "DayOfWeekProfile",
+    "IntradayVolatilityProfile",
+    "VolumeByTimeProfile",
 ]

bindings/python/tests/test_input_validation.py

@@ -35,6 +35,72 @@ 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
@@ -100,3 +166,115 @@ def test_family_10_ehlers_rejects_invalid_parameters():
         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,14 @@ def test_rsi_wilder_textbook_first_value():
     assert math.isclose(out[14], 70.464, abs_tol=0.05)
 
 
+def test_anchored_rsi_cumulative_reference():
+    """Cumulative anchored RSI: 10 -> 11 (+1) -> 9 (-2) -> 12 (+3)."""
+    out = ta.AnchoredRSI().batch(np.array([10.0, 11.0, 9.0, 12.0]))
+    assert math.isclose(out[1], 100.0, abs_tol=1e-9)
+    assert math.isclose(out[2], 100.0 - 100.0 / 1.5, abs_tol=1e-6)
+    assert math.isclose(out[3], 100.0 - 100.0 / 3.0, abs_tol=1e-6)
+
+
 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
@@ -429,6 +437,67 @@ def test_information_ratio_known_window():
     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)])
@@ -762,3 +831,206 @@ def test_yang_zhang_zero_movement_yields_zero():
     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

@@ -12,6 +12,7 @@ SCALAR_INDICATORS = [
     (ta.EMA, (14,)),
     (ta.WMA, (14,)),
     (ta.RSI, (14,)),
+    (ta.AnchoredRSI, ()),
     (ta.MACD, ()),
     (ta.BollingerBands, ()),
 ]
@@ -42,6 +43,7 @@ def test_reset_returns_to_initial_state(cls, args):
         (ta.EMA, (14,), 14),
         (ta.WMA, (14,), 14),
         (ta.RSI, (14,), 15),
+        (ta.AnchoredRSI, (), 2),
         (ta.BollingerBands, (20, 2.0), 20),
     ],
 )
@@ -129,3 +131,92 @@ def test_ehlers_indicators_lifecycle():
         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_seasonality.py

@@ -0,0 +1,132 @@
+"""Streaming-vs-batch equivalence and reference values for the Seasonality &
+Session family.
+
+These indicators read the full candle (including ``timestamp``), so they have a
+dedicated test rather than joining the timestamp-less parametrize harness in
+``test_new_indicators.py``.
+"""
+
+import numpy as np
+import pytest
+
+import wickra as ta
+
+HOUR_MS = 3_600_000
+
+
+@pytest.fixture(scope="module")
+def candle_columns():
+    """240 hourly candles (10 days) with valid OHLCV and epoch-ms timestamps."""
+    n = 240
+    t = np.arange(n, dtype=np.float64)
+    close = 100.0 + np.sin(t * 0.3) * 5.0 + np.cos(t * 0.1) * 3.0
+    open_ = close + np.sin(t * 0.5) * 0.5
+    high = np.maximum(open_, close) + 1.0
+    low = np.minimum(open_, close) - 1.0
+    volume = 1000.0 + (t % 24) * 50.0
+    timestamp = (np.arange(n, dtype=np.int64)) * HOUR_MS
+    return open_, high, low, close, volume, timestamp
+
+
+def _candles(cols):
+    open_, high, low, close, volume, timestamp = cols
+    return [
+        (open_[i], high[i], low[i], close[i], volume[i], int(timestamp[i]))
+        for i in range(len(close))
+    ]
+
+
+def _check_scalar(make, cols):
+    candles = _candles(cols)
+    a, b = make(), make()
+    stream = np.array(
+        [np.nan if (v := a.update(c)) is None else v for c in candles],
+        dtype=np.float64,
+    )
+    batch = np.asarray(b.batch(*cols))
+    np.testing.assert_allclose(stream, batch, equal_nan=True, rtol=1e-9, atol=1e-9)
+
+
+def _check_matrix(make, k, cols):
+    candles = _candles(cols)
+    a, b = make(), make()
+    rows = []
+    for c in candles:
+        out = a.update(c)
+        rows.append(np.full(k, np.nan) if out is None else np.asarray(out, dtype=float))
+    stream = np.vstack(rows)
+    batch = np.asarray(b.batch(*cols))
+    assert batch.shape == (len(candles), k)
+    np.testing.assert_allclose(stream, batch, equal_nan=True, rtol=1e-9, atol=1e-9)
+
+
+SCALAR = [
+    lambda: ta.SessionVwap(0),
+    lambda: ta.OvernightGap(0),
+    lambda: ta.SeasonalZScore(0),
+    lambda: ta.AverageDailyRange(3, 0),
+    lambda: ta.TurnOfMonth(3, 1, 0),
+]
+
+MATRIX = [
+    (lambda: ta.SessionHighLow(0), 2),
+    (lambda: ta.SessionRange(0), 3),
+    (lambda: ta.OvernightIntradayReturn(0), 2),
+    (lambda: ta.TimeOfDayReturnProfile(24, 0), 24),
+    (lambda: ta.IntradayVolatilityProfile(12, 0), 12),
+    (lambda: ta.VolumeByTimeProfile(24, 0), 24),
+    (lambda: ta.DayOfWeekProfile(0), 7),
+]
+
+
+@pytest.mark.parametrize("make", SCALAR)
+def test_scalar_streaming_equals_batch(make, candle_columns):
+    _check_scalar(make, candle_columns)
+
+
+@pytest.mark.parametrize("make,k", MATRIX)
+def test_matrix_streaming_equals_batch(make, k, candle_columns):
+    _check_matrix(make, k, candle_columns)
+
+
+def test_session_vwap_reference():
+    vwap = ta.SessionVwap(0)
+    # typical = close for a flat candle; volume-weighted within the day.
+    v1 = vwap.update((100.0, 100.0, 100.0, 100.0, 10.0, 0))
+    assert v1 == pytest.approx(100.0)
+    v2 = vwap.update((110.0, 110.0, 110.0, 110.0, 30.0, HOUR_MS))
+    assert v2 == pytest.approx(107.5)
+    # New day re-anchors.
+    v3 = vwap.update((200.0, 200.0, 200.0, 200.0, 5.0, 24 * HOUR_MS))
+    assert v3 == pytest.approx(200.0)
+
+
+def test_overnight_gap_reference():
+    gap = ta.OvernightGap(0)
+    assert gap.update((99.0, 101.0, 98.0, 100.0, 1.0, 0)) is None
+    g = gap.update((105.0, 106.0, 104.0, 105.5, 1.0, 24 * HOUR_MS))
+    assert g == pytest.approx(0.05)
+
+
+def test_session_high_low_reference():
+    shl = ta.SessionHighLow(0)
+    shl.update((100.0, 105.0, 99.0, 101.0, 1.0, 0))
+    out = shl.update((101.0, 108.0, 100.0, 107.0, 1.0, HOUR_MS))
+    assert out == (108.0, 99.0)
+
+
+def test_volume_by_time_profile_reference():
+    prof = ta.VolumeByTimeProfile(24, 0)
+    out = prof.update((100.0, 100.0, 100.0, 100.0, 500.0, HOUR_MS))  # 01:00 -> bucket 1
+    assert out[1] == pytest.approx(500.0)
+    assert out[0] == pytest.approx(0.0)
+
+
+def test_rejects_zero_buckets():
+    with pytest.raises(ValueError):
+        ta.TimeOfDayReturnProfile(0, 0)
+
+
+def test_average_daily_range_rejects_zero_period():
+    with pytest.raises(ValueError):
+        ta.AverageDailyRange(0, 0)

bindings/python/tests/test_smoke.py

@@ -97,3 +97,73 @@ def test_ehlers_super_smoother_batch_shape(sine_prices):
 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

@@ -201,3 +201,50 @@ def test_opening_range_streaming_matches_batch(ohlc_series):
         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/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
 [![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)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
 
 **Streaming-first technical indicators in the browser. `npm install
 wickra-wasm` — pure WebAssembly, runs anywhere a modern JS engine does.**
@@ -66,7 +66,5 @@ risk. The library is provided **as is**, without warranty of any kind.
 
 ## License
 
-Licensed under the **PolyForm Noncommercial License 1.0.0**. Personal projects,
-research, education, non-profits, and hobby trading bots are all fine; the one
-thing not allowed is commercial sale of the software or of services built
-around it. See [LICENSE](https://github.com/wickra-lib/wickra/blob/main/LICENSE).
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

clippy.toml

@@ -1,4 +1,4 @@
 # Proper nouns that appear in indicator documentation. They are real names,
 # not code identifiers, so `clippy::doc_markdown` must not demand backticks.
 # `..` keeps clippy's built-in default identifier list in addition to these.
-doc-valid-idents = ["LeBeau", ".."]
+doc-valid-idents = ["LeBeau", "McClellan", ".."]

crates/wickra-core/src/calendar.rs

@@ -0,0 +1,203 @@
+//! Pure calendar arithmetic for the timestamp-driven seasonality indicators.
+//!
+//! Every indicator in the *Seasonality & Session* family keys off the wall-clock
+//! fields of [`Candle::timestamp`](crate::Candle) (epoch milliseconds), shifted
+//! by a caller-supplied `utc_offset_minutes` so the buckets line up with the
+//! relevant exchange session rather than UTC. This module turns an epoch
+//! millisecond instant into its civil fields using Howard Hinnant's
+//! branch-light `civil_from_days` algorithm (the same one libc++ ships).
+//!
+//! All arithmetic is floor-based (`div_euclid`/`rem_euclid`) so instants before
+//! the Unix epoch decompose correctly without a dedicated negative-input branch.
+
+/// Civil (wall-clock) decomposition of an epoch-millisecond instant.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct CivilTime {
+    /// Proleptic Gregorian year (can be negative for instants before year 1).
+    pub(crate) year: i64,
+    /// Month of year, `1..=12`.
+    pub(crate) month: u32,
+    /// Day of month, `1..=31`.
+    pub(crate) day: u32,
+    /// Hour of day, `0..=23`.
+    pub(crate) hour: u32,
+    /// Minute of hour, `0..=59`.
+    pub(crate) minute: u32,
+    /// Day of week with Monday as `0` through Sunday as `6`.
+    pub(crate) weekday: u32,
+}
+
+impl CivilTime {
+    /// Minute of day, `0..=1439`.
+    pub(crate) const fn minute_of_day(&self) -> u32 {
+        self.hour * 60 + self.minute
+    }
+}
+
+/// Decompose an epoch-millisecond instant into local civil fields.
+///
+/// `utc_offset_minutes` shifts the instant before decomposition: `0` yields
+/// UTC, `-300` U.S. Eastern standard time, `60` Central European time, etc.
+pub(crate) fn civil_from_timestamp(millis: i64, utc_offset_minutes: i32) -> CivilTime {
+    let local_secs = millis.div_euclid(1000) + i64::from(utc_offset_minutes) * 60;
+    let days = local_secs.div_euclid(86_400);
+    let secs_of_day = local_secs.rem_euclid(86_400);
+    let hour = (secs_of_day / 3600) as u32;
+    let minute = ((secs_of_day % 3600) / 60) as u32;
+    let (year, month, day) = civil_from_days(days);
+    // 1970-01-01 was a Thursday; Monday-based weekday is `(z + 3) mod 7`.
+    let weekday = (days + 3).rem_euclid(7) as u32;
+    CivilTime {
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        weekday,
+    }
+}
+
+/// Gregorian `(year, month, day)` for a day count `z` relative to 1970-01-01.
+///
+/// Howard Hinnant, "chrono-Compatible Low-Level Date Algorithms".
+fn civil_from_days(z: i64) -> (i64, u32, u32) {
+    let z = z + 719_468;
+    let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
+    let doe = z - era * 146_097; // [0, 146096]
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; // [0, 399]
+    let year = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
+    let mp = (5 * doy + 2) / 153; // [0, 11]
+    let day = (doy - (153 * mp + 2) / 5 + 1) as u32; // [1, 31]
+    let month = if mp < 10 { mp + 3 } else { mp - 9 } as u32; // [1, 12]
+    (if month <= 2 { year + 1 } else { year }, month, day)
+}
+
+/// Whether `year` is a Gregorian leap year.
+pub(crate) const fn is_leap(year: i64) -> bool {
+    (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
+}
+
+/// Number of days in `month` (`1..=12`) of `year`.
+pub(crate) const fn days_in_month(year: i64, month: u32) -> u32 {
+    match month {
+        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+        4 | 6 | 9 | 11 => 30,
+        _ => {
+            if is_leap(year) {
+                29
+            } else {
+                28
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn epoch_zero_is_thursday_midnight() {
+        let t = civil_from_timestamp(0, 0);
+        assert_eq!(
+            t,
+            CivilTime {
+                year: 1970,
+                month: 1,
+                day: 1,
+                hour: 0,
+                minute: 0,
+                weekday: 3, // Thursday
+            }
+        );
+        assert_eq!(t.minute_of_day(), 0);
+    }
+
+    #[test]
+    fn known_utc_instant_mid_year() {
+        // 2021-06-15 13:45:00 UTC = 1623764700 s.
+        let t = civil_from_timestamp(1_623_764_700_000, 0);
+        assert_eq!(t.year, 2021);
+        assert_eq!(t.month, 6);
+        assert_eq!(t.day, 15);
+        assert_eq!(t.hour, 13);
+        assert_eq!(t.minute, 45);
+        assert_eq!(t.weekday, 1); // Tuesday
+        assert_eq!(t.minute_of_day(), 13 * 60 + 45);
+    }
+
+    #[test]
+    fn new_year_2021_is_friday() {
+        // 2021-01-01 00:00:00 UTC = 1609459200 s — exercises the m<=2 year bump.
+        let t = civil_from_timestamp(1_609_459_200_000, 0);
+        assert_eq!((t.year, t.month, t.day), (2021, 1, 1));
+        assert_eq!(t.weekday, 4); // Friday
+    }
+
+    #[test]
+    fn positive_offset_rolls_to_next_day() {
+        // 2021-01-01 23:30 UTC shifted +60 min -> 2021-01-02 00:30 local.
+        let base = 1_609_459_200_000 + (23 * 3600 + 30 * 60) * 1000;
+        let t = civil_from_timestamp(base, 60);
+        assert_eq!((t.year, t.month, t.day), (2021, 1, 2));
+        assert_eq!((t.hour, t.minute), (0, 30));
+        assert_eq!(t.weekday, 5); // Saturday
+    }
+
+    #[test]
+    fn negative_offset_rolls_to_previous_day() {
+        // 2021-01-01 00:30 UTC shifted -60 min -> 2020-12-31 23:30 local.
+        let base = 1_609_459_200_000 + 30 * 60 * 1000;
+        let t = civil_from_timestamp(base, -60);
+        assert_eq!((t.year, t.month, t.day), (2020, 12, 31));
+        assert_eq!((t.hour, t.minute), (23, 30));
+        assert_eq!(t.weekday, 3); // Thursday
+    }
+
+    #[test]
+    fn sub_epoch_millis_floor_correctly() {
+        // -1 ms -> 1969-12-31 23:59:59.999, a Wednesday.
+        let t = civil_from_timestamp(-1, 0);
+        assert_eq!((t.year, t.month, t.day), (1969, 12, 31));
+        assert_eq!((t.hour, t.minute), (23, 59));
+        assert_eq!(t.weekday, 2); // Wednesday
+    }
+
+    #[test]
+    fn far_negative_day_count_hits_pre_era_branch() {
+        // A day count below -719468 drives `z + 719468` negative, exercising the
+        // `z - 146096` era branch in civil_from_days (year < 1).
+        let (year, month, day) = civil_from_days(-1_000_000);
+        // -1_000_000 days before 1970-01-01 is 0768-02-04 BCE (proleptic
+        // Gregorian, astronomical year numbering where year 0 exists).
+        assert_eq!((year, month, day), (-768, 2, 4));
+    }
+
+    #[test]
+    fn leap_year_rules() {
+        assert!(is_leap(2000));
+        assert!(!is_leap(1900));
+        assert!(is_leap(2024));
+        assert!(!is_leap(2023));
+    }
+
+    #[test]
+    fn days_in_month_all_cases() {
+        assert_eq!(days_in_month(2023, 1), 31);
+        assert_eq!(days_in_month(2023, 4), 30);
+        assert_eq!(days_in_month(2023, 2), 28);
+        assert_eq!(days_in_month(2024, 2), 29);
+        assert_eq!(days_in_month(2023, 12), 31);
+        assert_eq!(days_in_month(2023, 11), 30);
+    }
+
+    #[test]
+    fn leap_day_decodes() {
+        // 2024-02-29 12:00 UTC.
+        let secs = 1_709_208_000; // 2024-02-29T12:00:00Z
+        let t = civil_from_timestamp(secs * 1000, 0);
+        assert_eq!((t.year, t.month, t.day), (2024, 2, 29));
+        assert_eq!(t.hour, 12);
+    }
+}

crates/wickra-core/src/cross_section.rs

@@ -0,0 +1,387 @@
+//! Cross-section value type: a market-breadth snapshot across a whole universe.
+//!
+//! A [`CrossSection`] is a single tick that carries the per-symbol state of
+//! *every* symbol in a universe at one point in time. It is the non-OHLCV input
+//! consumed by the market-breadth indicator family (advance/decline, `McClellan`,
+//! the TRIN / Arms index, the high-low index, ...), each of which aggregates the
+//! whole cross-section into a single breadth reading. This is the same
+//! one-rich-type-per-family pattern as [`DerivativesTick`] and [`OrderBook`].
+//!
+//! Each [`Member`] precomputes the per-symbol signals the breadth indicators
+//! need — a signed price `change` (whose sign classifies the symbol as
+//! advancing, declining or unchanged), the period `volume`, the
+//! `new_high` / `new_low` extreme flags, and the `above_ma` / `on_buy_signal`
+//! state flags — so the indicators stay stateless per tick and never have to
+//! track per-symbol history.
+//!
+//! [`DerivativesTick`]: crate::DerivativesTick
+//! [`OrderBook`]: crate::OrderBook
+
+use crate::error::{Error, Result};
+
+/// One symbol's contribution to a [`CrossSection`] tick.
+///
+/// Field invariants enforced by [`CrossSection::new`] when the member is placed
+/// into a tick:
+///
+/// - `change` is finite (its sign classifies the symbol — positive is
+///   advancing, negative is declining, zero is unchanged).
+/// - `volume` is finite and non-negative.
+///
+/// `new_high` / `new_low` are caller-supplied flags marking whether the symbol
+/// printed a new period extreme; `above_ma` / `on_buy_signal` are caller-supplied
+/// per-symbol state signals (whether the symbol trades above its reference moving
+/// average, and whether it is on a point-and-figure buy signal). None of the four
+/// flags carries a numeric invariant.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(
+    clippy::struct_excessive_bools,
+    reason = "the four flags are independent per-symbol breadth signals, not a state machine"
+)]
+pub struct Member {
+    /// Price change versus the previous close. Sign classifies the symbol:
+    /// positive is advancing, negative is declining, zero is unchanged.
+    pub change: f64,
+    /// Period volume for the symbol (finite, non-negative).
+    pub volume: f64,
+    /// Whether the symbol printed a new period high.
+    pub new_high: bool,
+    /// Whether the symbol printed a new period low.
+    pub new_low: bool,
+    /// Whether the symbol is trading above its reference moving average
+    /// (consumed by the `% Above Moving Average` breadth indicator).
+    pub above_ma: bool,
+    /// Whether the symbol is on a point-and-figure buy signal
+    /// (consumed by the `Bullish Percent Index` breadth indicator).
+    pub on_buy_signal: bool,
+}
+
+impl Member {
+    /// Assemble a cross-section member from its core signals, leaving the
+    /// extended per-symbol state flags (`above_ma`, `on_buy_signal`) cleared.
+    ///
+    /// The field invariants documented on [`Member`] are validated centrally by
+    /// [`CrossSection::new`] when the member is placed into a tick; this
+    /// constructor only assembles the value so the `#[non_exhaustive]` struct can
+    /// be built from outside the crate.
+    #[must_use]
+    pub const fn new(change: f64, volume: f64, new_high: bool, new_low: bool) -> Self {
+        Self {
+            change,
+            volume,
+            new_high,
+            new_low,
+            above_ma: false,
+            on_buy_signal: false,
+        }
+    }
+
+    /// Assemble a cross-section member including the extended per-symbol state
+    /// signals `above_ma` and `on_buy_signal`.
+    ///
+    /// Use this constructor for the breadth indicators that read per-symbol
+    /// state (`% Above Moving Average`, `Bullish Percent Index`); [`new`](Member::new)
+    /// is the shorthand that leaves both flags `false`.
+    #[must_use]
+    #[allow(
+        clippy::fn_params_excessive_bools,
+        reason = "mirrors the four independent per-symbol flag fields of Member"
+    )]
+    pub const fn with_signals(
+        change: f64,
+        volume: f64,
+        new_high: bool,
+        new_low: bool,
+        above_ma: bool,
+        on_buy_signal: bool,
+    ) -> Self {
+        Self {
+            change,
+            volume,
+            new_high,
+            new_low,
+            above_ma,
+            on_buy_signal,
+        }
+    }
+}
+
+/// A market-breadth cross-section: the per-symbol state of an entire universe at
+/// a single point in time.
+///
+/// Invariants enforced by [`new`](CrossSection::new):
+///
+/// - `members` is non-empty (a breadth reading needs at least one symbol).
+/// - every member's `change` is finite, and `volume` is finite and non-negative.
+///
+/// `timestamp` is a caller-defined epoch / resolution and is not validated.
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq)]
+pub struct CrossSection {
+    /// Per-symbol members of the universe for this tick.
+    pub members: Vec<Member>,
+    /// Tick timestamp (caller-defined epoch / resolution).
+    pub timestamp: i64,
+}
+
+impl CrossSection {
+    /// Construct a cross-section, validating every member invariant.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidCrossSection`] if `members` is empty, if any
+    /// member has a non-finite `change`, or if any member has a `volume` that is
+    /// not a finite non-negative number.
+    pub fn new(members: Vec<Member>, timestamp: i64) -> Result<Self> {
+        if members.is_empty() {
+            return Err(Error::InvalidCrossSection {
+                message: "cross-section must contain at least one member",
+            });
+        }
+        for member in &members {
+            if !member.change.is_finite() {
+                return Err(Error::InvalidCrossSection {
+                    message: "member change must be finite",
+                });
+            }
+            if !member.volume.is_finite() || member.volume < 0.0 {
+                return Err(Error::InvalidCrossSection {
+                    message: "member volume must be finite and non-negative",
+                });
+            }
+        }
+        Ok(Self { members, timestamp })
+    }
+
+    /// Construct a cross-section without validation. The caller asserts that
+    /// every invariant documented on [`CrossSection`] holds.
+    #[must_use]
+    pub const fn new_unchecked(members: Vec<Member>, timestamp: i64) -> Self {
+        Self { members, timestamp }
+    }
+
+    /// Number of advancing symbols (those with a strictly positive `change`).
+    #[must_use]
+    pub fn advancers(&self) -> usize {
+        self.members.iter().filter(|m| m.change > 0.0).count()
+    }
+
+    /// Number of declining symbols (those with a strictly negative `change`).
+    #[must_use]
+    pub fn decliners(&self) -> usize {
+        self.members.iter().filter(|m| m.change < 0.0).count()
+    }
+
+    /// Total volume traded by advancing symbols (those with positive `change`).
+    #[must_use]
+    pub fn advancing_volume(&self) -> f64 {
+        self.members
+            .iter()
+            .filter(|m| m.change > 0.0)
+            .map(|m| m.volume)
+            .sum()
+    }
+
+    /// Total volume traded by declining symbols (those with negative `change`).
+    #[must_use]
+    pub fn declining_volume(&self) -> f64 {
+        self.members
+            .iter()
+            .filter(|m| m.change < 0.0)
+            .map(|m| m.volume)
+            .sum()
+    }
+
+    /// Total volume traded across the whole universe.
+    #[must_use]
+    pub fn total_volume(&self) -> f64 {
+        self.members.iter().map(|m| m.volume).sum()
+    }
+
+    /// Number of symbols that printed a new period high.
+    #[must_use]
+    pub fn new_highs(&self) -> usize {
+        self.members.iter().filter(|m| m.new_high).count()
+    }
+
+    /// Number of symbols that printed a new period low.
+    #[must_use]
+    pub fn new_lows(&self) -> usize {
+        self.members.iter().filter(|m| m.new_low).count()
+    }
+
+    /// Number of symbols trading above their reference moving average.
+    #[must_use]
+    pub fn above_ma_count(&self) -> usize {
+        self.members.iter().filter(|m| m.above_ma).count()
+    }
+
+    /// Number of symbols on a point-and-figure buy signal.
+    #[must_use]
+    pub fn on_buy_signal_count(&self) -> usize {
+        self.members.iter().filter(|m| m.on_buy_signal).count()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn members() -> Vec<Member> {
+        vec![
+            Member::new(1.5, 100.0, true, false),
+            Member::new(-0.5, 50.0, false, true),
+            Member::new(0.0, 0.0, false, false),
+        ]
+    }
+
+    #[test]
+    fn new_accepts_valid() {
+        let cs = CrossSection::new(members(), 42).unwrap();
+        assert_eq!(cs.members.len(), 3);
+        assert_eq!(cs.timestamp, 42);
+        assert_eq!(cs.members[0].change, 1.5);
+        assert_eq!(cs.members[0].volume, 100.0);
+        assert!(cs.members[0].new_high);
+        assert!(cs.members[1].new_low);
+    }
+
+    #[test]
+    fn member_new_assembles_fields() {
+        let m = Member::new(2.0, 10.0, true, false);
+        assert_eq!(m.change, 2.0);
+        assert_eq!(m.volume, 10.0);
+        assert!(m.new_high);
+        assert!(!m.new_low);
+    }
+
+    #[test]
+    fn new_rejects_empty() {
+        assert!(matches!(
+            CrossSection::new(Vec::new(), 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_finite_change() {
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(f64::NAN, 10.0, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(f64::INFINITY, 10.0, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_negative_volume() {
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(1.0, -1.0, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_finite_volume() {
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(1.0, f64::NAN, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_unchecked_skips_validation() {
+        let cs = CrossSection::new_unchecked(vec![Member::new(f64::NAN, -1.0, false, false)], 7);
+        assert_eq!(cs.members.len(), 1);
+        assert_eq!(cs.timestamp, 7);
+    }
+
+    #[test]
+    fn advancers_and_decliners_count_by_sign() {
+        let cs = CrossSection::new(members(), 0).unwrap();
+        assert_eq!(cs.advancers(), 1);
+        assert_eq!(cs.decliners(), 1);
+    }
+
+    #[test]
+    fn unchanged_members_count_as_neither() {
+        let cs = CrossSection::new(
+            vec![
+                Member::new(0.0, 1.0, false, false),
+                Member::new(0.0, 1.0, false, false),
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(cs.advancers(), 0);
+        assert_eq!(cs.decliners(), 0);
+    }
+
+    #[test]
+    fn new_leaves_extended_flags_cleared() {
+        let m = Member::new(1.0, 10.0, true, false);
+        assert!(!m.above_ma);
+        assert!(!m.on_buy_signal);
+    }
+
+    #[test]
+    fn with_signals_assembles_all_fields() {
+        let m = Member::with_signals(2.0, 10.0, true, false, true, true);
+        assert_eq!(m.change, 2.0);
+        assert_eq!(m.volume, 10.0);
+        assert!(m.new_high);
+        assert!(!m.new_low);
+        assert!(m.above_ma);
+        assert!(m.on_buy_signal);
+    }
+
+    #[test]
+    fn volume_helpers_bucket_by_change_sign() {
+        let cs = CrossSection::new(
+            vec![
+                Member::new(1.5, 100.0, false, false), // advancing
+                Member::new(2.0, 40.0, false, false),  // advancing
+                Member::new(-0.5, 50.0, false, false), // declining
+                Member::new(0.0, 7.0, false, false),   // unchanged
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(cs.advancing_volume(), 140.0);
+        assert_eq!(cs.declining_volume(), 50.0);
+        assert_eq!(cs.total_volume(), 197.0);
+    }
+
+    #[test]
+    fn high_low_helpers_count_flags() {
+        let cs = CrossSection::new(
+            vec![
+                Member::new(1.0, 1.0, true, false),
+                Member::new(1.0, 1.0, true, false),
+                Member::new(-1.0, 1.0, false, true),
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(cs.new_highs(), 2);
+        assert_eq!(cs.new_lows(), 1);
+    }
+
+    #[test]
+    fn state_helpers_count_extended_flags() {
+        let cs = CrossSection::new(
+            vec![
+                Member::with_signals(1.0, 1.0, false, false, true, true),
+                Member::with_signals(1.0, 1.0, false, false, true, false),
+                Member::with_signals(-1.0, 1.0, false, false, false, true),
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(cs.above_ma_count(), 2);
+        assert_eq!(cs.on_buy_signal_count(), 2);
+    }
+}

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,42 @@ 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 },
+
+    /// A market-breadth cross-section whose members do not satisfy the
+    /// cross-section invariants (an empty universe, a non-finite change, or a
+    /// negative / non-finite volume) was provided. A cross-section is a
+    /// breadth input distinct from candles, ticks, order books and trades, so
+    /// it surfaces as its own variant.
+    #[error("invalid cross-section: {message}")]
+    InvalidCrossSection { message: &'static str },
+
+    /// A real-valued configuration parameter was outside its admissible range
+    /// (e.g. a non-positive standard-deviation multiplier, or a Kalman filter
+    /// covariance that is not strictly positive). This is the floating-point
+    /// analogue of [`Error::InvalidPeriod`], which only covers integer windows.
+    #[error("invalid parameter: {message}")]
+    InvalidParameter { 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/absolute_breadth_index.rs

@@ -0,0 +1,144 @@
+//! Absolute Breadth Index — the magnitude of net advancing-minus-declining issues.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Absolute Breadth Index (ABI) — the absolute value of net advancing issues,
+/// `|advancers - decliners|`.
+///
+/// The ABI ignores the *direction* of breadth and measures only its *magnitude*:
+/// a high reading means the universe moved decisively one way or the other (high
+/// internal activity / volatility), while a low reading means advances and
+/// declines were nearly balanced (a quiet, directionless market). It is sometimes
+/// called a "market thermometer" because elevated readings often cluster around
+/// turning points.
+///
+/// `Input = CrossSection`, `Output = f64`, `warmup_period == 1`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AbsoluteBreadthIndex, CrossSection, Indicator, Member};
+///
+/// let mut abi = AbsoluteBreadthIndex::new();
+/// // 2 advancers, 5 decliners -> |2 - 5| = 3.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::new(1.0, 10.0, false, false),
+///         Member::new(1.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(abi.update(tick), Some(3.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AbsoluteBreadthIndex {
+    has_emitted: bool,
+}
+
+impl AbsoluteBreadthIndex {
+    /// Construct a new Absolute Breadth Index indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for AbsoluteBreadthIndex {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let net = section.advancers() as f64 - section.decliners() as f64;
+        self.has_emitted = true;
+        Some(net.abs())
+    }
+
+    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 {
+        "AbsoluteBreadthIndex"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    fn section(up: usize, down: usize) -> CrossSection {
+        let mut members = Vec::new();
+        for _ in 0..up {
+            members.push(Member::new(1.0, 10.0, false, false));
+        }
+        for _ in 0..down {
+            members.push(Member::new(-1.0, 10.0, false, false));
+        }
+        members.push(Member::new(0.0, 10.0, false, false));
+        CrossSection::new(members, 0).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let abi = AbsoluteBreadthIndex::new();
+        assert_eq!(abi.name(), "AbsoluteBreadthIndex");
+        assert_eq!(abi.warmup_period(), 1);
+        assert!(!abi.is_ready());
+    }
+
+    #[test]
+    fn magnitude_ignores_direction() {
+        let mut abi = AbsoluteBreadthIndex::new();
+        assert_eq!(abi.update(section(2, 5)), Some(3.0));
+        // Same magnitude with the direction reversed.
+        let mut abi2 = AbsoluteBreadthIndex::new();
+        assert_eq!(abi2.update(section(5, 2)), Some(3.0));
+    }
+
+    #[test]
+    fn balanced_universe_yields_zero() {
+        let mut abi = AbsoluteBreadthIndex::new();
+        assert_eq!(abi.update(section(3, 3)), Some(0.0));
+        assert!(abi.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut abi = AbsoluteBreadthIndex::new();
+        abi.update(section(2, 5));
+        assert!(abi.is_ready());
+        abi.reset();
+        assert!(!abi.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![section(2, 5), section(5, 2), section(3, 3)];
+        let mut a = AbsoluteBreadthIndex::new();
+        let mut b = AbsoluteBreadthIndex::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,157 @@
+//! Advance/Decline Volume Line — cumulative net advancing-minus-declining volume.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Advance/Decline Volume Line (AD Volume Line) — the running cumulative sum of
+/// net advancing volume across a universe.
+///
+/// On each [`CrossSection`] tick the net is `advancing volume - declining volume`,
+/// where advancing volume is the total volume of symbols with a positive change
+/// and declining volume the total volume of symbols with a negative change. The
+/// line accumulates this net over time, so a rising line means volume is flowing
+/// into advancing issues (healthy participation) while a falling line warns that
+/// declining issues are carrying the volume — the volume-weighted analogue of the
+/// plain Advance/Decline Line.
+///
+/// `Input = CrossSection`, `Output = f64`, `warmup_period == 1` (defined from the
+/// first tick).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AdVolumeLine, CrossSection, Indicator, Member};
+///
+/// let mut adv = AdVolumeLine::new();
+/// // advancing volume 150, declining volume 50 -> net +100.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::new(1.0, 150.0, false, false),
+///         Member::new(-1.0, 50.0, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(adv.update(tick), Some(100.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdVolumeLine {
+    line: f64,
+    has_emitted: bool,
+}
+
+impl AdVolumeLine {
+    /// Construct a new Advance/Decline Volume Line indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            line: 0.0,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for AdVolumeLine {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let net = section.advancing_volume() - section.declining_volume();
+        self.line += net;
+        self.has_emitted = true;
+        Some(self.line)
+    }
+
+    fn reset(&mut self) {
+        self.line = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "AdVolumeLine"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    fn tick(items: &[(f64, f64)]) -> CrossSection {
+        CrossSection::new(
+            items
+                .iter()
+                .map(|&(change, volume)| Member::new(change, volume, false, false))
+                .collect(),
+            0,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let adv = AdVolumeLine::new();
+        assert_eq!(adv.name(), "AdVolumeLine");
+        assert_eq!(adv.warmup_period(), 1);
+        assert!(!adv.is_ready());
+    }
+
+    #[test]
+    fn first_tick_emits_net_volume() {
+        let mut adv = AdVolumeLine::new();
+        assert_eq!(adv.update(tick(&[(1.0, 150.0), (-1.0, 50.0)])), Some(100.0));
+        assert!(adv.is_ready());
+    }
+
+    #[test]
+    fn line_accumulates_across_ticks() {
+        let mut adv = AdVolumeLine::new();
+        assert_eq!(adv.update(tick(&[(1.0, 150.0), (-1.0, 50.0)])), Some(100.0));
+        assert_eq!(adv.update(tick(&[(1.0, 60.0), (-1.0, 60.0)])), Some(100.0));
+        assert_eq!(adv.update(tick(&[(1.0, 30.0)])), Some(130.0));
+    }
+
+    #[test]
+    fn unchanged_volume_is_ignored() {
+        let mut adv = AdVolumeLine::new();
+        // Unchanged symbols (zero change) contribute to neither bucket.
+        assert_eq!(adv.update(tick(&[(0.0, 1000.0), (1.0, 10.0)])), Some(10.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut adv = AdVolumeLine::new();
+        adv.update(tick(&[(1.0, 100.0)]));
+        assert!(adv.is_ready());
+        adv.reset();
+        assert!(!adv.is_ready());
+        assert_eq!(adv.update(tick(&[(1.0, 20.0)])), Some(20.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![
+            tick(&[(1.0, 150.0), (-1.0, 50.0)]),
+            tick(&[(1.0, 60.0), (-1.0, 60.0)]),
+            tick(&[(1.0, 30.0)]),
+        ];
+        let mut a = AdVolumeLine::new();
+        let mut b = AdVolumeLine::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,168 @@
+//! Advance/Decline Line — cumulative net advancing-minus-declining issues.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Advance/Decline Line (A/D Line) — the running cumulative sum of net advancing
+/// issues across a universe.
+///
+/// On each [`CrossSection`] tick the net breadth is `advancers - decliners`:
+/// the number of symbols with a positive price change minus the number with a
+/// negative change (unchanged symbols are ignored). The line accumulates this
+/// net value over time, so a rising line means advancers have persistently
+/// outnumbered decliners — broad participation — while a falling line warns that
+/// a rally is being carried by fewer and fewer names (a breadth divergence when
+/// the index itself is still rising).
+///
+/// `Input = CrossSection`, `Output = f64`. The line is defined from the very
+/// first tick, so `warmup_period == 1` and the indicator is ready after one
+/// update.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AdvanceDecline, CrossSection, Indicator, Member};
+///
+/// let mut ad = AdvanceDecline::new();
+/// // 3 advancers, 1 decliner -> net +2.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::new(1.0, 10.0, false, false),
+///         Member::new(0.5, 10.0, false, false),
+///         Member::new(2.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(ad.update(tick), Some(2.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdvanceDecline {
+    line: f64,
+    has_emitted: bool,
+}
+
+impl AdvanceDecline {
+    /// Construct a new Advance/Decline Line indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            line: 0.0,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for AdvanceDecline {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let net = section.advancers() as f64 - section.decliners() as f64;
+        self.line += net;
+        self.has_emitted = true;
+        Some(self.line)
+    }
+
+    fn reset(&mut self) {
+        self.line = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "AdvanceDecline"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    /// Build a cross-section with `up` advancers, `down` decliners and `flat`
+    /// unchanged symbols.
+    fn section(up: usize, down: usize, flat: usize) -> CrossSection {
+        let mut members = Vec::new();
+        for _ in 0..up {
+            members.push(Member::new(1.0, 10.0, false, false));
+        }
+        for _ in 0..down {
+            members.push(Member::new(-1.0, 10.0, false, false));
+        }
+        for _ in 0..flat {
+            members.push(Member::new(0.0, 10.0, false, false));
+        }
+        CrossSection::new(members, 0).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let ad = AdvanceDecline::new();
+        assert_eq!(ad.name(), "AdvanceDecline");
+        assert_eq!(ad.warmup_period(), 1);
+        assert!(!ad.is_ready());
+    }
+
+    #[test]
+    fn first_tick_emits_net_breadth() {
+        let mut ad = AdvanceDecline::new();
+        assert_eq!(ad.update(section(3, 1, 0)), Some(2.0));
+        assert!(ad.is_ready());
+    }
+
+    #[test]
+    fn line_accumulates_across_ticks() {
+        let mut ad = AdvanceDecline::new();
+        assert_eq!(ad.update(section(3, 1, 0)), Some(2.0)); // +2 -> 2
+        assert_eq!(ad.update(section(1, 4, 0)), Some(-1.0)); // -3 -> -1
+        assert_eq!(ad.update(section(2, 0, 0)), Some(1.0)); // +2 -> 1
+    }
+
+    #[test]
+    fn unchanged_symbols_are_ignored() {
+        let mut ad = AdvanceDecline::new();
+        // 2 up, 2 down, 5 unchanged -> net 0, line stays flat.
+        assert_eq!(ad.update(section(2, 2, 5)), Some(0.0));
+        assert_eq!(ad.update(section(2, 2, 5)), Some(0.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut ad = AdvanceDecline::new();
+        ad.update(section(5, 0, 0));
+        assert!(ad.is_ready());
+        ad.reset();
+        assert!(!ad.is_ready());
+        // Line restarts from zero, not from the pre-reset value.
+        assert_eq!(ad.update(section(1, 0, 0)), Some(1.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![
+            section(3, 1, 2),
+            section(1, 4, 0),
+            section(2, 2, 1),
+            section(5, 0, 3),
+        ];
+        let mut a = AdvanceDecline::new();
+        let mut b = AdvanceDecline::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,151 @@
+//! Advance/Decline Ratio — advancing issues divided by declining issues.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Advance/Decline Ratio (ADR) — the number of advancing symbols divided by the
+/// number of declining symbols across a universe.
+///
+/// On each [`CrossSection`] tick the ratio is `advancers / decliners`: a reading
+/// above one means advancing issues outnumber declining ones (broad strength),
+/// while a reading below one signals broad weakness. Because it is a ratio rather
+/// than a difference, the ADR is comparable across universes of different sizes.
+///
+/// When a tick has no declining symbols the denominator is floored to one, so the
+/// ratio degrades gracefully to the advancer count instead of dividing by zero.
+///
+/// `Input = CrossSection`, `Output = f64`. The ratio is defined from the first
+/// tick, so `warmup_period == 1` and the indicator is ready after one update.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AdvanceDeclineRatio, CrossSection, Indicator, Member};
+///
+/// let mut adr = AdvanceDeclineRatio::new();
+/// // 3 advancers, 1 decliner -> ratio 3.0.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::new(1.0, 10.0, false, false),
+///         Member::new(0.5, 10.0, false, false),
+///         Member::new(2.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(adr.update(tick), Some(3.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdvanceDeclineRatio {
+    has_emitted: bool,
+}
+
+impl AdvanceDeclineRatio {
+    /// Construct a new Advance/Decline Ratio indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for AdvanceDeclineRatio {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let advancers = section.advancers() as f64;
+        let decliners = section.decliners().max(1) as f64;
+        self.has_emitted = true;
+        Some(advancers / decliners)
+    }
+
+    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 {
+        "AdvanceDeclineRatio"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    fn section(up: usize, down: usize) -> CrossSection {
+        let mut members = Vec::new();
+        for _ in 0..up {
+            members.push(Member::new(1.0, 10.0, false, false));
+        }
+        for _ in 0..down {
+            members.push(Member::new(-1.0, 10.0, false, false));
+        }
+        // A non-empty unchanged member guarantees a valid universe when both
+        // counts are zero.
+        members.push(Member::new(0.0, 10.0, false, false));
+        CrossSection::new(members, 0).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let adr = AdvanceDeclineRatio::new();
+        assert_eq!(adr.name(), "AdvanceDeclineRatio");
+        assert_eq!(adr.warmup_period(), 1);
+        assert!(!adr.is_ready());
+    }
+
+    #[test]
+    fn first_tick_emits_ratio() {
+        let mut adr = AdvanceDeclineRatio::new();
+        assert_eq!(adr.update(section(3, 1)), Some(3.0));
+        assert!(adr.is_ready());
+    }
+
+    #[test]
+    fn zero_decliners_floors_denominator() {
+        let mut adr = AdvanceDeclineRatio::new();
+        // 4 advancers, 0 decliners -> 4 / max(0, 1) = 4.0.
+        assert_eq!(adr.update(section(4, 0)), Some(4.0));
+    }
+
+    #[test]
+    fn no_advancers_yields_zero() {
+        let mut adr = AdvanceDeclineRatio::new();
+        assert_eq!(adr.update(section(0, 5)), Some(0.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut adr = AdvanceDeclineRatio::new();
+        adr.update(section(3, 1));
+        assert!(adr.is_ready());
+        adr.reset();
+        assert!(!adr.is_ready());
+        assert_eq!(adr.update(section(2, 1)), Some(2.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![section(3, 1), section(4, 0), section(0, 5), section(2, 2)];
+        let mut a = AdvanceDeclineRatio::new();
+        let mut b = AdvanceDeclineRatio::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -91,7 +91,7 @@ impl Adx {
     }
 }
 
-fn directional_movement(prev: &Candle, current: &Candle) -> (f64, f64) {
+pub(crate) fn directional_movement(prev: &Candle, current: &Candle) -> (f64, f64) {
     let up = current.high - prev.high;
     let down = prev.low - current.low;
     let plus_dm = if up > down && up > 0.0 { up } else { 0.0 };

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

@@ -0,0 +1,284 @@
+//! Anchored Relative Strength Index.
+
+use crate::traits::Indicator;
+
+/// Anchored RSI — a cumulative Relative Strength Index whose averaging begins at
+/// a user-chosen anchor bar rather than over a fixed Wilder period.
+///
+/// Where [`crate::Rsi`] uses Wilder's `period`-length smoothing, Anchored RSI
+/// accumulates *every* up- and down-move since the anchor with equal weight, so
+/// it answers "what is the RSI of the entire move since the anchor point?". The
+/// running relative strength is `Σ gains / Σ losses` over all bars in the
+/// current anchor window (the bar count cancels, so this equals
+/// `avg_gain / avg_loss`):
+///
+/// ```text
+/// RSI_t = 100 - 100 / (1 + Σ_{i ≥ anchor} gain_i / Σ_{i ≥ anchor} loss_i)
+/// ```
+///
+/// As with [`crate::AnchoredVwap`], the anchor is chosen at runtime:
+/// [`AnchoredRsi::set_anchor`] re-anchors at the **next** bar that arrives,
+/// clearing the running sums. Because RSI needs a price *change*, the first bar
+/// of a fresh anchor window only seeds the previous close and emits `None`; the
+/// first value follows on the second bar (warmup period 2).
+///
+/// Saturation follows the standard convention: a window with no losses yet (and
+/// at least one gain) reads 100, no gains yet reads 0, and a perfectly flat
+/// window reads the neutral 50. Non-finite inputs are ignored, leaving the last
+/// value unchanged.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AnchoredRsi, Indicator};
+///
+/// let mut indicator = AnchoredRsi::new();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let price = 100.0 + (f64::from(i) * 0.5).sin() * 5.0;
+///     // Re-anchor at bar 40 (e.g. a major swing low).
+///     if i == 40 {
+///         indicator.set_anchor();
+///     }
+///     last = indicator.update(price);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AnchoredRsi {
+    prev_close: Option<f64>,
+    sum_gain: f64,
+    sum_loss: f64,
+    last_value: Option<f64>,
+    pending_anchor: bool,
+}
+
+impl AnchoredRsi {
+    /// Construct a fresh Anchored RSI. The first bar to arrive is the anchor.
+    pub const fn new() -> Self {
+        Self {
+            prev_close: None,
+            sum_gain: 0.0,
+            sum_loss: 0.0,
+            last_value: None,
+            pending_anchor: false,
+        }
+    }
+
+    /// Mark a re-anchor: the **next** [`Indicator::update`] call clears the
+    /// running sums and previous close before folding in its own bar, starting
+    /// a fresh anchored window.
+    pub fn set_anchor(&mut self) {
+        self.pending_anchor = true;
+    }
+
+    /// Current anchored RSI value if at least one price change has been
+    /// observed in the current anchor window.
+    pub const fn value(&self) -> Option<f64> {
+        self.last_value
+    }
+
+    fn rsi_from_sums(sum_gain: f64, sum_loss: f64) -> f64 {
+        if sum_loss == 0.0 {
+            if sum_gain == 0.0 {
+                // No movement at all -> RSI undefined; standard convention returns 50.
+                50.0
+            } else {
+                100.0
+            }
+        } else {
+            let rs = sum_gain / sum_loss;
+            100.0 - 100.0 / (1.0 + rs)
+        }
+    }
+}
+
+impl Indicator for AnchoredRsi {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        if !input.is_finite() {
+            return self.last_value;
+        }
+
+        if self.pending_anchor {
+            self.prev_close = None;
+            self.sum_gain = 0.0;
+            self.sum_loss = 0.0;
+            self.last_value = None;
+            self.pending_anchor = false;
+        }
+
+        let Some(prev) = self.prev_close else {
+            self.prev_close = Some(input);
+            return None;
+        };
+        self.prev_close = Some(input);
+
+        let diff = input - prev;
+        if diff > 0.0 {
+            self.sum_gain += diff;
+        } else if diff < 0.0 {
+            self.sum_loss -= diff;
+        }
+
+        let value = Self::rsi_from_sums(self.sum_gain, self.sum_loss);
+        self.last_value = Some(value);
+        Some(value)
+    }
+
+    fn reset(&mut self) {
+        self.prev_close = None;
+        self.sum_gain = 0.0;
+        self.sum_loss = 0.0;
+        self.last_value = None;
+        self.pending_anchor = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        2
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last_value.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "AnchoredRSI"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn accessors_and_metadata() {
+        let indicator = AnchoredRsi::new();
+        assert_eq!(indicator.name(), "AnchoredRSI");
+        assert_eq!(indicator.warmup_period(), 2);
+        assert_eq!(indicator.value(), None);
+        assert!(!indicator.is_ready());
+    }
+
+    #[test]
+    fn first_bar_seeds_and_returns_none() {
+        let mut indicator = AnchoredRsi::new();
+        assert_eq!(indicator.update(100.0), None);
+        assert!(!indicator.is_ready());
+        // Second bar produces the first value.
+        assert!(indicator.update(101.0).is_some());
+        assert!(indicator.is_ready());
+    }
+
+    #[test]
+    fn pure_uptrend_saturates_at_100() {
+        let mut indicator = AnchoredRsi::new();
+        let out = indicator.batch(&[10.0, 11.0, 12.0, 13.0]);
+        assert_relative_eq!(out[3].unwrap(), 100.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn pure_downtrend_saturates_at_0() {
+        let mut indicator = AnchoredRsi::new();
+        let out = indicator.batch(&[13.0, 12.0, 11.0, 10.0]);
+        assert_relative_eq!(out[3].unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn flat_window_reads_50() {
+        let mut indicator = AnchoredRsi::new();
+        let out = indicator.batch(&[42.0, 42.0, 42.0]);
+        assert_relative_eq!(out[2].unwrap(), 50.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn cumulative_reference_values() {
+        // prices 10 -> 11 (+1) -> 9 (-2) -> 12 (+3)
+        // after bar2: sum_gain=1, sum_loss=2 -> rs=0.5 -> 100 - 100/1.5 = 33.3333
+        // after bar3: sum_gain=4, sum_loss=2 -> rs=2.0 -> 100 - 100/3   = 66.6667
+        let mut indicator = AnchoredRsi::new();
+        let out = indicator.batch(&[10.0, 11.0, 9.0, 12.0]);
+        assert_relative_eq!(out[1].unwrap(), 100.0, epsilon = 1e-9);
+        assert_relative_eq!(out[2].unwrap(), 33.333_333_333, epsilon = 1e-6);
+        assert_relative_eq!(out[3].unwrap(), 66.666_666_666, epsilon = 1e-6);
+    }
+
+    #[test]
+    fn set_anchor_clears_old_window() {
+        // Downtrend, then re-anchor and pump an uptrend: the new window must
+        // read 100, not the blended value.
+        let mut indicator = AnchoredRsi::new();
+        indicator.batch(&[20.0, 19.0, 18.0, 17.0]);
+        assert_relative_eq!(indicator.value().unwrap(), 0.0, epsilon = 1e-12);
+        indicator.set_anchor();
+        // First bar after anchor re-seeds (None), second bar emits.
+        assert_eq!(indicator.update(50.0), None);
+        let after = indicator.update(51.0).unwrap();
+        assert_relative_eq!(after, 100.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn set_anchor_before_first_bar_acts_as_normal_start() {
+        let mut indicator = AnchoredRsi::new();
+        indicator.set_anchor();
+        assert_eq!(indicator.update(10.0), None);
+        assert_relative_eq!(indicator.update(11.0).unwrap(), 100.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut indicator = AnchoredRsi::new();
+        indicator.batch(&[10.0, 11.0, 12.0]);
+        let before = indicator.value();
+        assert!(before.is_some());
+        assert_eq!(indicator.update(f64::NAN), before);
+        assert_eq!(indicator.update(f64::INFINITY), before);
+        assert_eq!(indicator.value(), before);
+    }
+
+    #[test]
+    fn non_finite_before_any_bar_returns_none() {
+        let mut indicator = AnchoredRsi::new();
+        assert_eq!(indicator.update(f64::NAN), None);
+        assert!(!indicator.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut indicator = AnchoredRsi::new();
+        indicator.batch(&[10.0, 11.0, 12.0]);
+        assert!(indicator.is_ready());
+        indicator.reset();
+        assert!(!indicator.is_ready());
+        assert_eq!(indicator.value(), None);
+        assert_eq!(indicator.update(50.0), None);
+    }
+
+    #[test]
+    fn stays_in_0_100_range() {
+        let prices: Vec<f64> = (0..200)
+            .map(|i| 100.0 + (f64::from(i) * 0.7).sin() * 10.0)
+            .collect();
+        let mut indicator = AnchoredRsi::new();
+        for value in indicator.batch(&prices).into_iter().flatten() {
+            assert!((0.0..=100.0).contains(&value), "RSI out of range: {value}");
+        }
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (1..=40)
+            .map(|i| (f64::from(i) * 0.3).sin() * 5.0 + f64::from(i))
+            .collect();
+        let mut a = AnchoredRsi::new();
+        let mut b = AnchoredRsi::new();
+        assert_eq!(
+            a.batch(&prices),
+            prices.iter().map(|p| b.update(*p)).collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,231 @@
+//! Average Daily Range (ADR) — the mean high-minus-low range of the last `period`
+//! completed calendar-day sessions.
+
+use std::collections::VecDeque;
+
+use crate::calendar::civil_from_timestamp;
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Average Daily Range over the last `period` completed sessions.
+///
+/// The indicator tracks the running high / low of the current session (the
+/// wall-clock day of [`Candle::timestamp`](crate::Candle) shifted by
+/// `utc_offset_minutes`). When a new day begins, the just-finished session's
+/// range (`high - low`) joins a rolling window of the last `period` completed
+/// days, and the reported value is their mean. The current, still-forming day is
+/// excluded until it closes. No value is produced until the first session
+/// completes.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, AverageDailyRange};
+///
+/// let hour = 3_600_000;
+/// let mut adr = AverageDailyRange::new(2, 0).unwrap();
+/// // Day 1 range 10 (high 110, low 100) — still forming, so None.
+/// assert!(adr.update(Candle::new(105.0, 110.0, 100.0, 108.0, 1.0, 0).unwrap()).is_none());
+/// // First bar of day 2 closes day 1: ADR = 10.
+/// let v = adr.update(Candle::new(108.0, 112.0, 106.0, 109.0, 1.0, 24 * hour).unwrap()).unwrap();
+/// assert!((v - 10.0).abs() < 1e-9);
+/// ```
+#[derive(Debug, Clone)]
+pub struct AverageDailyRange {
+    period: usize,
+    utc_offset_minutes: i32,
+    day_key: Option<(i64, u32, u32)>,
+    cur_high: f64,
+    cur_low: f64,
+    completed: VecDeque<f64>,
+    sum: f64,
+}
+
+impl AverageDailyRange {
+    /// Construct an ADR indicator over `period` completed days.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize, utc_offset_minutes: i32) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            utc_offset_minutes,
+            day_key: None,
+            cur_high: f64::NEG_INFINITY,
+            cur_low: f64::INFINITY,
+            completed: VecDeque::with_capacity(period),
+            sum: 0.0,
+        })
+    }
+
+    /// Configured `(period, utc_offset_minutes)`.
+    pub const fn params(&self) -> (usize, i32) {
+        (self.period, self.utc_offset_minutes)
+    }
+
+    /// Most recent ADR if at least one session has completed.
+    pub fn value(&self) -> Option<f64> {
+        if self.completed.is_empty() {
+            None
+        } else {
+            Some(self.sum / self.completed.len() as f64)
+        }
+    }
+}
+
+impl Indicator for AverageDailyRange {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let civil = civil_from_timestamp(candle.timestamp, self.utc_offset_minutes);
+        let key = (civil.year, civil.month, civil.day);
+        match self.day_key {
+            Some(prev) if prev == key => {
+                if candle.high > self.cur_high {
+                    self.cur_high = candle.high;
+                }
+                if candle.low < self.cur_low {
+                    self.cur_low = candle.low;
+                }
+            }
+            Some(_) => {
+                let range = self.cur_high - self.cur_low;
+                self.completed.push_back(range);
+                self.sum += range;
+                if self.completed.len() > self.period {
+                    self.sum -= self
+                        .completed
+                        .pop_front()
+                        .expect("len > period implies a front element");
+                }
+                self.day_key = Some(key);
+                self.cur_high = candle.high;
+                self.cur_low = candle.low;
+            }
+            None => {
+                self.day_key = Some(key);
+                self.cur_high = candle.high;
+                self.cur_low = candle.low;
+            }
+        }
+        self.value()
+    }
+
+    fn reset(&mut self) {
+        self.day_key = None;
+        self.cur_high = f64::NEG_INFINITY;
+        self.cur_low = f64::INFINITY;
+        self.completed.clear();
+        self.sum = 0.0;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        !self.completed.is_empty()
+    }
+
+    fn name(&self) -> &'static str {
+        "AverageDailyRange"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    const HOUR: i64 = 3_600_000;
+    const DAY: i64 = 24 * HOUR;
+
+    fn c(high: f64, low: f64, ts: i64) -> Candle {
+        let mid = f64::midpoint(high, low);
+        Candle::new(mid, high, low, mid, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(
+            AverageDailyRange::new(0, 0),
+            Err(Error::PeriodZero)
+        ));
+    }
+
+    #[test]
+    fn metadata_and_accessors() {
+        let adr = AverageDailyRange::new(5, -60).unwrap();
+        assert_eq!(adr.params(), (5, -60));
+        assert_eq!(adr.name(), "AverageDailyRange");
+        assert_eq!(adr.warmup_period(), 5);
+        assert!(!adr.is_ready());
+        assert!(adr.value().is_none());
+    }
+
+    #[test]
+    fn averages_completed_day_ranges() {
+        let mut adr = AverageDailyRange::new(3, 0).unwrap();
+        // Day 1: range 10.
+        assert!(adr.update(c(110.0, 100.0, 0)).is_none());
+        assert!(adr.update(c(108.0, 104.0, HOUR)).is_none());
+        // Day 2 opens -> day 1 (range 10) completes.
+        let v = adr.update(c(120.0, 110.0, DAY)).unwrap();
+        assert_relative_eq!(v, 10.0);
+        assert!(adr.is_ready());
+        // Day 3 opens -> day 2 (range 10) completes: mean of [10, 10] = 10.
+        let v = adr.update(c(130.0, 100.0, 2 * DAY)).unwrap();
+        assert_relative_eq!(v, 10.0);
+    }
+
+    #[test]
+    fn rolls_off_oldest_day_beyond_period() {
+        let mut adr = AverageDailyRange::new(2, 0).unwrap();
+        adr.update(c(110.0, 100.0, 0)); // day 1 range 10
+        let v = adr.update(c(125.0, 110.0, DAY)).unwrap(); // close day 1 -> [10]
+        assert_relative_eq!(v, 10.0);
+        // Close day 2 (range 125-110=15) -> window [10, 15], mean 12.5.
+        let v = adr.update(c(130.0, 110.0, 2 * DAY)).unwrap();
+        assert_relative_eq!(v, 12.5);
+        // Close day 3 (range 130-110=20) -> window [15, 20], oldest (10) rolled off.
+        let v = adr.update(c(140.0, 138.0, 3 * DAY)).unwrap();
+        assert_relative_eq!(v, 17.5);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut adr = AverageDailyRange::new(2, 0).unwrap();
+        adr.update(c(110.0, 100.0, 0));
+        adr.update(c(120.0, 110.0, DAY));
+        adr.reset();
+        assert!(!adr.is_ready());
+        assert!(adr.value().is_none());
+        assert!(adr.update(c(50.0, 40.0, 2 * DAY)).is_none());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..60)
+            .map(|i| {
+                c(
+                    110.0 + f64::from(i % 5),
+                    100.0 - f64::from(i % 3),
+                    i64::from(i) * 6 * HOUR,
+                )
+            })
+            .collect();
+        let mut a = AverageDailyRange::new(4, 0).unwrap();
+        let mut b = AverageDailyRange::new(4, 0).unwrap();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,92 @@
+//! Average Price (AVGPRICE).
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Average Price (`AVGPRICE`) — the bar's `(open + high + low + close) / 4`.
+///
+/// A per-bar price aggregate that, unlike [`TypicalPrice`](crate::TypicalPrice)
+/// and [`WeightedClose`](crate::WeightedClose), folds in the open as well as the
+/// high, low and close. As a stateless transform it emits a value from the very
+/// first candle.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, AvgPrice};
+///
+/// let mut indicator = AvgPrice::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 AvgPrice {
+    has_emitted: bool,
+}
+
+impl AvgPrice {
+    /// Construct a new Average Price transform.
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for AvgPrice {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        Some(candle.avg_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 {
+        "AVGPRICE"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn averages_the_four_prices() {
+        // (open + high + low + close) / 4 = (10 + 14 + 6 + 12) / 4 = 10.5.
+        let candle = Candle::new(10.0, 14.0, 6.0, 12.0, 1.0, 0).unwrap();
+        let mut ap = AvgPrice::new();
+        assert!(!ap.is_ready());
+        assert_relative_eq!(ap.update(candle).unwrap(), 10.5, epsilon = 1e-12);
+        assert!(ap.is_ready());
+    }
+
+    #[test]
+    fn accessors_and_reset() {
+        let mut ap = AvgPrice::new();
+        assert_eq!(ap.name(), "AVGPRICE");
+        assert_eq!(ap.warmup_period(), 1);
+        let candle = Candle::new(10.0, 14.0, 6.0, 12.0, 1.0, 0).unwrap();
+        let _ = ap.update(candle);
+        assert!(ap.is_ready());
+        ap.reset();
+        assert!(!ap.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_neutral_spread.rs

@@ -0,0 +1,247 @@
+//! Beta-neutral spread: the rolling OLS regression residual of two series.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// The beta-neutral spread between two assets — the residual of a rolling
+/// ordinary-least-squares regression of `a` on `b`.
+///
+/// Each `update` takes one `(a, b)` price pair. Over the trailing window of
+/// `period` pairs the indicator fits the hedge ratio `β` (and intercept `α`) by
+/// OLS and reports the **current** residual:
+///
+/// ```text
+/// β = cov(a, b) / var(b)        α = ā − β · b̄
+/// spread = a_now − (α + β · b_now)
+/// ```
+///
+/// Subtracting `β · b` removes `a`'s exposure to `b`, so the spread is market-
+/// (beta-)neutral: it is what is left after the common factor is hedged out.
+/// Positive means `a` is rich relative to its hedge, negative means cheap — the
+/// raw signal a pairs trade fades. Where [`crate::PairSpreadZScore`] standardises
+/// this residual into a z-score and [`crate::Cointegration`] bundles it with an
+/// ADF test, this indicator returns the residual itself, in price units.
+///
+/// If `b` is flat over the window (`var(b) = 0`) there is no defined slope; the
+/// indicator falls back to `β = 0`, so the spread becomes `a_now − ā`.
+///
+/// Each `update` is `O(1)`: four running sums (`Σa`, `Σb`, `Σb²`, `Σab`) are
+/// maintained as the window slides.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BetaNeutralSpread, Indicator};
+///
+/// let mut s = BetaNeutralSpread::new(20).unwrap();
+/// let mut last = None;
+/// for t in 0..40 {
+///     let b = 100.0 + f64::from(t);
+///     // a = 2·b + 5 exactly ⇒ the regression explains a fully ⇒ spread ≈ 0.
+///     last = s.update((2.0 * b + 5.0, b));
+/// }
+/// assert!(last.unwrap().abs() < 1e-6);
+/// ```
+#[derive(Debug, Clone)]
+pub struct BetaNeutralSpread {
+    period: usize,
+    window: VecDeque<(f64, f64)>,
+    sum_a: f64,
+    sum_b: f64,
+    sum_bb: f64,
+    sum_ab: f64,
+}
+
+impl BetaNeutralSpread {
+    /// Construct a new beta-neutral spread.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2` — a regression slope
+    /// needs at least two points.
+    pub fn new(period: usize) -> Result<Self> {
+        if period < 2 {
+            return Err(Error::InvalidPeriod {
+                message: "beta-neutral spread 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 look-back window.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for BetaNeutralSpread {
+    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 (beta, intercept) = if var_b == 0.0 {
+            (0.0, mean_a)
+        } else {
+            let cov = self.sum_ab / n - mean_a * mean_b;
+            let slope = cov / var_b;
+            (slope, mean_a - slope * mean_b)
+        };
+        Some(a - (intercept + beta * 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 {
+        "BetaNeutralSpread"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_period_below_two() {
+        assert!(BetaNeutralSpread::new(1).is_err());
+        assert!(BetaNeutralSpread::new(2).is_ok());
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let s = BetaNeutralSpread::new(20).unwrap();
+        assert_eq!(s.period(), 20);
+        assert_eq!(s.warmup_period(), 20);
+        assert_eq!(s.name(), "BetaNeutralSpread");
+        assert!(!s.is_ready());
+    }
+
+    #[test]
+    fn warmup_returns_none() {
+        let mut s = BetaNeutralSpread::new(3).unwrap();
+        assert_eq!(s.update((1.0, 1.0)), None);
+        assert_eq!(s.update((2.0, 2.0)), None);
+        assert!(s.update((3.0, 3.0)).is_some());
+        assert!(s.is_ready());
+    }
+
+    #[test]
+    fn perfect_linear_relationship_has_zero_spread() {
+        let pairs: Vec<(f64, f64)> = (0..40)
+            .map(|t| {
+                let b = 100.0 + f64::from(t);
+                (2.0 * b + 5.0, b)
+            })
+            .collect();
+        let last = BetaNeutralSpread::new(20)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, 0.0, epsilon = 1e-6);
+    }
+
+    #[test]
+    fn dislocation_produces_nonzero_spread() {
+        // a tracks 2·b, then the last bar jumps up ⇒ positive residual.
+        let mut pairs: Vec<(f64, f64)> = (0..19)
+            .map(|t| {
+                let b = 100.0 + f64::from(t);
+                (2.0 * b + 5.0, b)
+            })
+            .collect();
+        pairs.push((2.0 * 119.0 + 5.0 + 10.0, 119.0));
+        let last = BetaNeutralSpread::new(20)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert!(last > 1.0, "spread {last}");
+    }
+
+    #[test]
+    fn flat_b_falls_back_to_demeaned_a() {
+        // b constant ⇒ β = 0 ⇒ spread = a − mean(a). Last window of a = 0..9,
+        // mean = 4.5, last a = 9 ⇒ spread = 4.5.
+        let pairs: Vec<(f64, f64)> = (0..10).map(|t| (f64::from(t), 7.0)).collect();
+        let last = BetaNeutralSpread::new(10)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, 4.5, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut s = BetaNeutralSpread::new(4).unwrap();
+        s.batch(&[(1.0, 2.0), (2.0, 4.0), (3.0, 5.0), (4.0, 9.0), (5.0, 2.0)]);
+        assert!(s.is_ready());
+        s.reset();
+        assert!(!s.is_ready());
+        assert_eq!(s.update((1.0, 1.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let pairs: Vec<(f64, f64)> = (0..60)
+            .map(|t| {
+                let b = 30.0 + 0.7 * f64::from(t);
+                (1.8 * b + 2.0 + (f64::from(t) * 0.4).sin(), b)
+            })
+            .collect();
+        let batch = BetaNeutralSpread::new(20).unwrap().batch(&pairs);
+        let mut s = BetaNeutralSpread::new(20).unwrap();
+        let streamed: Vec<_> = pairs.iter().map(|p| s.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

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

@@ -0,0 +1,165 @@
+//! Breadth Thrust (Zweig) — a moving average of the advancing-issues share.
+
+use crate::cross_section::CrossSection;
+use crate::error::Result;
+use crate::traits::Indicator;
+use crate::Sma;
+
+/// Breadth Thrust (Zweig) — a simple moving average of the advancing-issues
+/// share, `advancers / (advancers + decliners)`.
+///
+/// Martin Zweig's breadth thrust smooths the fraction of participating issues
+/// that are advancing over a short window (the classic period is 10). A "thrust"
+/// fires when this average climbs from below ~0.40 (oversold, washed-out breadth)
+/// to above ~0.615 within about ten sessions — historically a rare, reliable
+/// signal that a powerful new advance has begun with broad participation.
+///
+/// Each tick's share floors the participating count to one, so a tick with no
+/// advancing or declining issues contributes a defined `0.0` instead of dividing
+/// by zero. The reading is `None` until `period` ticks have been seen.
+///
+/// `Input = CrossSection`, `Output = f64` (a share in `0..=1`),
+/// `warmup_period == period`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BreadthThrust, CrossSection, Indicator, Member};
+///
+/// let mut bt = BreadthThrust::new(2).unwrap();
+/// let up = CrossSection::new(vec![Member::new(1.0, 1.0, false, false)], 0).unwrap();
+/// assert_eq!(bt.update(up.clone()), None); // warming up
+/// assert_eq!(bt.update(up), Some(1.0)); // both ticks 100% advancing
+/// ```
+#[derive(Debug, Clone)]
+pub struct BreadthThrust {
+    sma: Sma,
+}
+
+impl BreadthThrust {
+    /// Construct a new Breadth Thrust over the given window length.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`](crate::Error::PeriodZero) if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        Ok(Self {
+            sma: Sma::new(period)?,
+        })
+    }
+
+    /// Configured window length.
+    #[must_use]
+    pub const fn period(&self) -> usize {
+        self.sma.period()
+    }
+}
+
+impl Indicator for BreadthThrust {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let advancers = section.advancers();
+        let decliners = section.decliners();
+        let participating = (advancers + decliners).max(1) as f64;
+        let share = advancers as f64 / participating;
+        self.sma.update(share)
+    }
+
+    fn reset(&mut self) {
+        self.sma.reset();
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.sma.period()
+    }
+
+    fn is_ready(&self) -> bool {
+        self.sma.value().is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "BreadthThrust"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::error::Error;
+    use crate::traits::BatchExt;
+
+    fn section(up: usize, down: usize) -> CrossSection {
+        let mut members = Vec::new();
+        for _ in 0..up {
+            members.push(Member::new(1.0, 10.0, false, false));
+        }
+        for _ in 0..down {
+            members.push(Member::new(-1.0, 10.0, false, false));
+        }
+        members.push(Member::new(0.0, 10.0, false, false));
+        CrossSection::new(members, 0).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bt = BreadthThrust::new(10).unwrap();
+        assert_eq!(bt.name(), "BreadthThrust");
+        assert_eq!(bt.warmup_period(), 10);
+        assert_eq!(bt.period(), 10);
+        assert!(!bt.is_ready());
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(BreadthThrust::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn averages_the_advancing_share() {
+        let mut bt = BreadthThrust::new(2).unwrap();
+        // share = 8 / 10 = 0.8 ; window not full yet.
+        assert_eq!(bt.update(section(8, 2)), None);
+        // share = 6 / 10 = 0.6 ; SMA(2) = (0.8 + 0.6) / 2 = 0.7.
+        let value = bt.update(section(6, 4)).unwrap();
+        assert!((value - 0.7).abs() < 1e-9);
+        assert!(bt.is_ready());
+        // share = 5 / 10 = 0.5 ; SMA(2) = (0.6 + 0.5) / 2 = 0.55.
+        let value = bt.update(section(5, 5)).unwrap();
+        assert!((value - 0.55).abs() < 1e-9);
+    }
+
+    #[test]
+    fn empty_participation_floors_to_zero_share() {
+        let mut bt = BreadthThrust::new(1).unwrap();
+        // No advancers or decliners -> 0 / max(0, 1) = 0.0.
+        assert_eq!(bt.update(section(0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bt = BreadthThrust::new(2).unwrap();
+        bt.update(section(8, 2));
+        bt.update(section(6, 4));
+        assert!(bt.is_ready());
+        bt.reset();
+        assert!(!bt.is_ready());
+        assert_eq!(bt.update(section(8, 2)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![section(8, 2), section(6, 4), section(5, 5), section(0, 0)];
+        let mut a = BreadthThrust::new(2).unwrap();
+        let mut b = BreadthThrust::new(2).unwrap();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,147 @@
+//! Bullish Percent Index — share of a universe on a point-and-figure buy signal.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Bullish Percent Index (BPI) — the percentage of symbols in a universe that are
+/// currently on a point-and-figure buy signal.
+///
+/// On each [`CrossSection`] tick the value is `100 * on_buy_signal_count /
+/// universe size`, read from the per-symbol `on_buy_signal` flag (the caller
+/// evaluates each symbol's point-and-figure chart when it builds the tick). It is
+/// a bounded `0..=100` gauge of how many issues are in a confirmed uptrend.
+/// Readings above 70 are considered overbought (broad strength, but a crowded
+/// market) and below 30 oversold; reversals from those zones are classic BPI
+/// buy/sell triggers.
+///
+/// `Input = CrossSection`, `Output = f64` (a percentage in `0..=100`),
+/// `warmup_period == 1`. The universe is non-empty by construction, so the share
+/// is always defined.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BullishPercentIndex, CrossSection, Indicator, Member};
+///
+/// let mut bpi = BullishPercentIndex::new();
+/// // 2 of 4 symbols on a buy signal -> 50%.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::with_signals(1.0, 10.0, false, false, false, true),
+///         Member::with_signals(1.0, 10.0, false, false, false, true),
+///         Member::with_signals(-1.0, 10.0, false, false, false, false),
+///         Member::with_signals(-1.0, 10.0, false, false, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(bpi.update(tick), Some(50.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct BullishPercentIndex {
+    has_emitted: bool,
+}
+
+impl BullishPercentIndex {
+    /// Construct a new Bullish Percent Index indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for BullishPercentIndex {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let bullish = section.on_buy_signal_count() as f64;
+        let total = section.members.len() as f64;
+        self.has_emitted = true;
+        Some(100.0 * bullish / total)
+    }
+
+    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 {
+        "BullishPercentIndex"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    fn tick(bullish: usize, bearish: usize) -> CrossSection {
+        let mut members = Vec::new();
+        for _ in 0..bullish {
+            members.push(Member::with_signals(1.0, 10.0, false, false, false, true));
+        }
+        for _ in 0..bearish {
+            members.push(Member::with_signals(-1.0, 10.0, false, false, false, false));
+        }
+        CrossSection::new(members, 0).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let bpi = BullishPercentIndex::new();
+        assert_eq!(bpi.name(), "BullishPercentIndex");
+        assert_eq!(bpi.warmup_period(), 1);
+        assert!(!bpi.is_ready());
+    }
+
+    #[test]
+    fn first_tick_emits_percentage() {
+        let mut bpi = BullishPercentIndex::new();
+        assert_eq!(bpi.update(tick(2, 2)), Some(50.0));
+        assert!(bpi.is_ready());
+    }
+
+    #[test]
+    fn all_bullish_is_one_hundred() {
+        let mut bpi = BullishPercentIndex::new();
+        assert_eq!(bpi.update(tick(5, 0)), Some(100.0));
+    }
+
+    #[test]
+    fn none_bullish_is_zero() {
+        let mut bpi = BullishPercentIndex::new();
+        assert_eq!(bpi.update(tick(0, 4)), Some(0.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut bpi = BullishPercentIndex::new();
+        bpi.update(tick(2, 2));
+        assert!(bpi.is_ready());
+        bpi.reset();
+        assert!(!bpi.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![tick(2, 2), tick(5, 0), tick(0, 4)];
+        let mut a = BullishPercentIndex::new();
+        let mut b = BullishPercentIndex::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

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

@@ -0,0 +1,163 @@
+//! Cumulative Volume Index — running total of volume-normalised net advancing volume.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Cumulative Volume Index (CVI) — the running total of *volume-normalised* net
+/// advancing volume across a universe.
+///
+/// On each [`CrossSection`] tick the increment is `(advancing volume - declining
+/// volume) / total volume`: the share of the tick's total volume that flowed,
+/// net, into advancing issues. The index accumulates this share over time. Where
+/// the raw [`AdVolumeLine`](crate::AdVolumeLine) sums *absolute* net volume — and
+/// so drifts with secular growth in trading activity — the CVI normalises each
+/// tick by its own total volume, so a one-share-net day in a thin market counts
+/// the same as in a heavy one. This keeps the index comparable across regimes of
+/// very different volume.
+///
+/// When a tick has zero total volume the net is necessarily zero too, so the
+/// increment is zero and the index is unchanged (the divisor is floored to the
+/// smallest positive `f64` purely to keep the division defined).
+///
+/// `Input = CrossSection`, `Output = f64`, `warmup_period == 1`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{CrossSection, CumulativeVolumeIndex, Indicator, Member};
+///
+/// let mut cvi = CumulativeVolumeIndex::new();
+/// // adv vol 150, dec vol 50, total 200 -> (150 - 50) / 200 = 0.5.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::new(1.0, 150.0, false, false),
+///         Member::new(-1.0, 50.0, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(cvi.update(tick), Some(0.5));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct CumulativeVolumeIndex {
+    index: f64,
+    has_emitted: bool,
+}
+
+impl CumulativeVolumeIndex {
+    /// Construct a new Cumulative Volume Index indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            index: 0.0,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for CumulativeVolumeIndex {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let net = section.advancing_volume() - section.declining_volume();
+        let total = section.total_volume().max(f64::MIN_POSITIVE);
+        self.index += net / total;
+        self.has_emitted = true;
+        Some(self.index)
+    }
+
+    fn reset(&mut self) {
+        self.index = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "CumulativeVolumeIndex"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    fn tick(items: &[(f64, f64)]) -> CrossSection {
+        CrossSection::new(
+            items
+                .iter()
+                .map(|&(change, volume)| Member::new(change, volume, false, false))
+                .collect(),
+            0,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let cvi = CumulativeVolumeIndex::new();
+        assert_eq!(cvi.name(), "CumulativeVolumeIndex");
+        assert_eq!(cvi.warmup_period(), 1);
+        assert!(!cvi.is_ready());
+    }
+
+    #[test]
+    fn first_tick_emits_normalised_net() {
+        let mut cvi = CumulativeVolumeIndex::new();
+        assert_eq!(cvi.update(tick(&[(1.0, 150.0), (-1.0, 50.0)])), Some(0.5));
+        assert!(cvi.is_ready());
+    }
+
+    #[test]
+    fn index_accumulates_normalised_shares() {
+        let mut cvi = CumulativeVolumeIndex::new();
+        assert_eq!(cvi.update(tick(&[(1.0, 150.0), (-1.0, 50.0)])), Some(0.5));
+        // adv 60, dec 60, total 120 -> net 0 -> index unchanged.
+        assert_eq!(cvi.update(tick(&[(1.0, 60.0), (-1.0, 60.0)])), Some(0.5));
+    }
+
+    #[test]
+    fn zero_total_volume_leaves_index_unchanged() {
+        let mut cvi = CumulativeVolumeIndex::new();
+        cvi.update(tick(&[(1.0, 150.0), (-1.0, 50.0)]));
+        // A tick with no volume at all: net 0 / floored divisor -> 0 increment.
+        assert_eq!(cvi.update(tick(&[(0.0, 0.0)])), Some(0.5));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut cvi = CumulativeVolumeIndex::new();
+        cvi.update(tick(&[(1.0, 150.0), (-1.0, 50.0)]));
+        assert!(cvi.is_ready());
+        cvi.reset();
+        assert!(!cvi.is_ready());
+        assert_eq!(cvi.update(tick(&[(1.0, 100.0)])), Some(1.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![
+            tick(&[(1.0, 150.0), (-1.0, 50.0)]),
+            tick(&[(1.0, 60.0), (-1.0, 60.0)]),
+            tick(&[(0.0, 0.0)]),
+        ];
+        let mut a = CumulativeVolumeIndex::new();
+        let mut b = CumulativeVolumeIndex::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,127 @@
+//! Cumulative Volume Delta — running sum of signed trade volume.
+
+use crate::microstructure::Trade;
+use crate::traits::Indicator;
+
+/// Cumulative Volume Delta (CVD) — the running sum of [signed volume].
+///
+/// ```text
+/// CVDₜ = CVDₜ₋₁ + sizeₜ · (+1 if buy, −1 if sell)
+/// ```
+///
+/// CVD is an unbounded running total: a rising line signals net buying pressure
+/// over the session, a falling line net selling. Divergence between CVD and
+/// price is a classic absorption / exhaustion signal. Call [`reset`] at the
+/// start of each session to re-anchor the cumulative total at zero.
+///
+/// `Input = Trade`, `Output = f64`. Ready after the first trade.
+///
+/// [signed volume]: crate::SignedVolume
+/// [`reset`]: crate::Indicator::reset
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{CumulativeVolumeDelta, Indicator, Side, Trade};
+///
+/// let mut cvd = CumulativeVolumeDelta::new();
+/// assert_eq!(cvd.update(Trade::new(100.0, 5.0, Side::Buy, 0).unwrap()), Some(5.0));
+/// assert_eq!(cvd.update(Trade::new(100.0, 2.0, Side::Sell, 1).unwrap()), Some(3.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct CumulativeVolumeDelta {
+    cumulative: f64,
+    has_emitted: bool,
+}
+
+impl CumulativeVolumeDelta {
+    /// Construct a new CVD indicator with a zero running total.
+    pub const fn new() -> Self {
+        Self {
+            cumulative: 0.0,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for CumulativeVolumeDelta {
+    type Input = Trade;
+    type Output = f64;
+
+    fn update(&mut self, trade: Trade) -> Option<f64> {
+        self.has_emitted = true;
+        self.cumulative += trade.size * trade.side.sign();
+        Some(self.cumulative)
+    }
+
+    fn reset(&mut self) {
+        self.cumulative = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "CumulativeVolumeDelta"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::microstructure::Side;
+    use crate::traits::BatchExt;
+
+    fn trade(size: f64, side: Side, ts: i64) -> Trade {
+        Trade::new(100.0, size, side, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let cvd = CumulativeVolumeDelta::new();
+        assert_eq!(cvd.name(), "CumulativeVolumeDelta");
+        assert_eq!(cvd.warmup_period(), 1);
+        assert!(!cvd.is_ready());
+    }
+
+    #[test]
+    fn accumulates_signed_volume() {
+        let mut cvd = CumulativeVolumeDelta::new();
+        assert_eq!(cvd.update(trade(5.0, Side::Buy, 0)), Some(5.0));
+        assert_eq!(cvd.update(trade(2.0, Side::Sell, 1)), Some(3.0));
+        assert_eq!(cvd.update(trade(4.0, Side::Sell, 2)), Some(-1.0));
+        assert!(cvd.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let trades: Vec<Trade> = (0..20)
+            .map(|i| {
+                let side = if i % 3 == 0 { Side::Sell } else { Side::Buy };
+                trade(1.0 + (i % 4) as f64, side, i)
+            })
+            .collect();
+        let mut a = CumulativeVolumeDelta::new();
+        let mut b = CumulativeVolumeDelta::new();
+        assert_eq!(
+            a.batch(&trades),
+            trades.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_re_anchors_at_zero() {
+        let mut cvd = CumulativeVolumeDelta::new();
+        cvd.update(trade(5.0, Side::Buy, 0));
+        cvd.reset();
+        assert!(!cvd.is_ready());
+        // After reset the running total starts again from zero.
+        assert_eq!(cvd.update(trade(2.0, Side::Buy, 1)), Some(2.0));
+    }
+}

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

@@ -0,0 +1,202 @@
+//! Day-of-Week Profile — the mean bar return for each weekday.
+
+use crate::calendar::civil_from_timestamp;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+const DAYS: usize = 7;
+
+/// Day-of-Week Profile output: the per-weekday mean return.
+///
+/// `bins[i]` is the mean simple return of all bars whose local weekday was `i`,
+/// with Monday as `0` through Sunday as `6`. Weekdays with no bars read `0.0`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct DayOfWeekProfileOutput {
+    /// Per-weekday mean return, Monday first. Always length 7.
+    pub bins: Vec<f64>,
+}
+
+/// Mean bar return bucketed by local weekday (Monday `0` .. Sunday `6`).
+///
+/// Each bar's simple return `close / previous_close - 1` is accumulated into the
+/// bucket of its local weekday (the wall-clock day of
+/// [`Candle::timestamp`](crate::Candle) shifted by `utc_offset_minutes`), and the
+/// profile reports the running mean per weekday. The first bar produces no output.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, DayOfWeekProfile};
+///
+/// let day = 24 * 3_600_000;
+/// let mut prof = DayOfWeekProfile::new(0);
+/// // 1970-01-01 was a Thursday (weekday 3).
+/// assert!(prof.update(Candle::new(100.0, 100.0, 100.0, 100.0, 1.0, 0).unwrap()).is_none());
+/// let out = prof.update(Candle::new(101.0, 101.0, 101.0, 101.0, 1.0, day).unwrap()).unwrap();
+/// assert_eq!(out.bins.len(), 7);
+/// ```
+#[derive(Debug, Clone)]
+pub struct DayOfWeekProfile {
+    utc_offset_minutes: i32,
+    prev_close: Option<f64>,
+    sum: [f64; DAYS],
+    count: [u64; DAYS],
+    last: Option<DayOfWeekProfileOutput>,
+}
+
+impl DayOfWeekProfile {
+    /// Construct a Day-of-Week Profile with the given UTC offset (minutes).
+    pub const fn new(utc_offset_minutes: i32) -> Self {
+        Self {
+            utc_offset_minutes,
+            prev_close: None,
+            sum: [0.0; DAYS],
+            count: [0; DAYS],
+            last: None,
+        }
+    }
+
+    /// Configured UTC offset in minutes.
+    pub const fn utc_offset_minutes(&self) -> i32 {
+        self.utc_offset_minutes
+    }
+
+    /// Most recent profile if at least one return has been recorded.
+    pub fn value(&self) -> Option<&DayOfWeekProfileOutput> {
+        self.last.as_ref()
+    }
+
+    fn snapshot(&self) -> DayOfWeekProfileOutput {
+        let bins = self
+            .sum
+            .iter()
+            .zip(&self.count)
+            .map(|(total, n)| if *n > 0 { total / *n as f64 } else { 0.0 })
+            .collect();
+        DayOfWeekProfileOutput { bins }
+    }
+}
+
+impl Indicator for DayOfWeekProfile {
+    type Input = Candle;
+    type Output = DayOfWeekProfileOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<DayOfWeekProfileOutput> {
+        let civil = civil_from_timestamp(candle.timestamp, self.utc_offset_minutes);
+        let result = if let Some(prev) = self.prev_close {
+            let ret = if prev == 0.0 {
+                0.0
+            } else {
+                candle.close / prev - 1.0
+            };
+            let day = civil.weekday as usize;
+            self.sum[day] += ret;
+            self.count[day] += 1;
+            let out = self.snapshot();
+            self.last = Some(out.clone());
+            Some(out)
+        } else {
+            None
+        };
+        self.prev_close = Some(candle.close);
+        result
+    }
+
+    fn reset(&mut self) {
+        self.prev_close = None;
+        self.sum = [0.0; DAYS];
+        self.count = [0; DAYS];
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        2
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "DayOfWeekProfile"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    const DAY: i64 = 24 * 3_600_000;
+
+    fn c(close: f64, ts: i64) -> Candle {
+        Candle::new(close, close, close, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn metadata_and_accessors() {
+        let prof = DayOfWeekProfile::new(60);
+        assert_eq!(prof.utc_offset_minutes(), 60);
+        assert_eq!(prof.name(), "DayOfWeekProfile");
+        assert_eq!(prof.warmup_period(), 2);
+        assert!(!prof.is_ready());
+        assert!(prof.value().is_none());
+    }
+
+    #[test]
+    fn buckets_by_weekday() {
+        let mut prof = DayOfWeekProfile::new(0);
+        // 1970-01-01 Thursday (3); 01-02 Friday (4).
+        assert!(prof.update(c(100.0, 0)).is_none());
+        let out = prof.update(c(101.0, DAY)).unwrap(); // Friday return +0.01
+        assert_eq!(out.bins.len(), 7);
+        assert_relative_eq!(out.bins[4], 0.01); // Friday
+        assert_relative_eq!(out.bins[3], 0.0); // Thursday had no return
+        assert!(prof.is_ready());
+    }
+
+    #[test]
+    fn averages_same_weekday_across_weeks() {
+        let mut prof = DayOfWeekProfile::new(0);
+        prof.update(c(100.0, 0)); // Thu
+        prof.update(c(101.0, DAY)); // Fri +0.01
+                                    // Jump to next Friday (7 days later from day 0 -> +7 days, weekday 4).
+        prof.update(c(100.0, 7 * DAY)); // Thu+? actually day 7 -> weekday (7+3)%7=3 Thu
+        let out = prof.update(c(103.0, 8 * DAY)).unwrap(); // day 8 -> Fri, return
+                                                           // Friday now has two samples; both positive.
+        assert!(out.bins[4] > 0.0);
+    }
+
+    #[test]
+    fn zero_prev_close_uses_zero_return() {
+        let mut prof = DayOfWeekProfile::new(0);
+        prof.update(c(0.0, 0));
+        let out = prof.update(c(5.0, DAY)).unwrap();
+        assert_relative_eq!(out.bins[4], 0.0); // Friday, guarded return 0
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut prof = DayOfWeekProfile::new(0);
+        prof.update(c(100.0, 0));
+        prof.update(c(101.0, DAY));
+        prof.reset();
+        assert!(!prof.is_ready());
+        assert!(prof.value().is_none());
+        assert!(prof.update(c(100.0, 2 * DAY)).is_none());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..30)
+            .map(|i| c(100.0 + f64::from(i % 5), i64::from(i) * DAY))
+            .collect();
+        let mut a = DayOfWeekProfile::new(0);
+        let mut b = DayOfWeekProfile::new(0);
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,258 @@
+//! Depth Slope — how fast resting liquidity accumulates away from the mid.
+
+use crate::microstructure::{Level, OrderBook};
+use crate::traits::Indicator;
+
+/// Ordinary-least-squares slope of cumulative resting size against distance
+/// from the mid, over the levels of one book side.
+///
+/// `signed_distance` is `+1.0` for the ask side (price above the mid) and
+/// `−1.0` for the bid side (price below the mid), so the regressor `x` —
+/// distance from the mid — is non-negative on both sides. The response `y` is
+/// the cumulative size walking outward from the touch. Returns `0.0` for a
+/// degenerate fit where every level sits at the same distance (zero variance in
+/// `x`).
+fn cumulative_slope(levels: &[Level], mid: f64, signed_distance: f64) -> f64 {
+    let count = levels.len() as f64;
+    let mut cumulative = 0.0;
+    let mut sum_x = 0.0;
+    let mut sum_y = 0.0;
+    let mut sum_xy = 0.0;
+    let mut sum_xx = 0.0;
+    for level in levels {
+        let x = signed_distance * (level.price - mid);
+        cumulative += level.size;
+        sum_x += x;
+        sum_y += cumulative;
+        sum_xy += x * cumulative;
+        sum_xx += x * x;
+    }
+    let denom = count * sum_xx - sum_x * sum_x;
+    if denom == 0.0 {
+        return 0.0;
+    }
+    (count * sum_xy - sum_x * sum_y) / denom
+}
+
+/// Depth Slope — the average rate at which cumulative resting size grows with
+/// distance from the mid, across the bid and ask sides of the book.
+///
+/// For each side the indicator runs an ordinary-least-squares regression of
+/// cumulative size (walking outward from the touch) on the level's distance
+/// from the mid, then reports the mean of the two slopes:
+///
+/// ```text
+/// slope_side = OLS slope of (|priceᵢ − mid|, Σ_{j≤i} sizeⱼ)
+/// depthSlope = (slope_bid + slope_ask) / 2
+/// ```
+///
+/// Because the response is *cumulative* size it never decreases with distance,
+/// so the slope is non-negative: it is a magnitude, not a direction. A large
+/// slope means cumulative liquidity builds quickly away from the touch — a deep
+/// book that absorbs large orders with little walking; a small slope is a thin,
+/// shallow book. A book whose size is concentrated at the touch and thins out
+/// behind it (a fragile book) reads a *smaller* slope than one of equal total
+/// depth that thickens with distance.
+///
+/// A side with fewer than two levels carries no slope, so the indicator returns
+/// `0.0` whenever either side has fewer than two levels (including an empty
+/// book).
+///
+/// `Input = OrderBook`, `Output = f64`. Stateless; ready after the first
+/// snapshot.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DepthSlope, Indicator, Level, OrderBook};
+///
+/// // Both sides thicken linearly away from the mid (sizes 1, 2, 3 …).
+/// let book = OrderBook::new(
+///     vec![Level::new(99.0, 1.0).unwrap(), Level::new(98.0, 2.0).unwrap()],
+///     vec![Level::new(101.0, 1.0).unwrap(), Level::new(102.0, 2.0).unwrap()],
+/// )
+/// .unwrap();
+/// let mut ds = DepthSlope::new();
+/// assert!(ds.update(book).unwrap() > 0.0);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct DepthSlope {
+    has_emitted: bool,
+}
+
+impl DepthSlope {
+    /// Construct a new depth-slope indicator.
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for DepthSlope {
+    type Input = OrderBook;
+    type Output = f64;
+
+    fn update(&mut self, book: OrderBook) -> Option<f64> {
+        self.has_emitted = true;
+        let Some(mid) = book.mid() else {
+            return Some(0.0);
+        };
+        if book.bids.len() < 2 || book.asks.len() < 2 {
+            return Some(0.0);
+        }
+        let bid_slope = cumulative_slope(&book.bids, mid, -1.0);
+        let ask_slope = cumulative_slope(&book.asks, mid, 1.0);
+        Some(f64::midpoint(bid_slope, ask_slope))
+    }
+
+    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 {
+        "DepthSlope"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn book(bids: &[(f64, f64)], asks: &[(f64, f64)]) -> OrderBook {
+        let to_levels = |xs: &[(f64, f64)]| {
+            xs.iter()
+                .map(|&(p, s)| Level::new(p, s).unwrap())
+                .collect::<Vec<_>>()
+        };
+        OrderBook::new(to_levels(bids), to_levels(asks)).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let ds = DepthSlope::new();
+        assert_eq!(ds.name(), "DepthSlope");
+        assert_eq!(ds.warmup_period(), 1);
+        assert!(!ds.is_ready());
+    }
+
+    #[test]
+    fn thickening_book_has_positive_slope() {
+        let mut ds = DepthSlope::new();
+        let out = ds
+            .update(book(
+                &[(99.0, 1.0), (98.0, 2.0), (97.0, 3.0)],
+                &[(101.0, 1.0), (102.0, 2.0), (103.0, 3.0)],
+            ))
+            .unwrap();
+        assert!(out > 0.0);
+        assert!(ds.is_ready());
+    }
+
+    #[test]
+    fn front_loaded_book_has_smaller_slope_than_back_loaded() {
+        // Same total depth (6 per side), but one book thickens away from the
+        // touch and the other thins. Cumulative slope is non-negative for both;
+        // the back-loaded book accumulates faster, so its slope is larger.
+        let mut back = DepthSlope::new();
+        let back_slope = back
+            .update(book(
+                &[(99.0, 1.0), (98.0, 2.0), (97.0, 3.0)],
+                &[(101.0, 1.0), (102.0, 2.0), (103.0, 3.0)],
+            ))
+            .unwrap();
+        let mut front = DepthSlope::new();
+        let front_slope = front
+            .update(book(
+                &[(99.0, 3.0), (98.0, 2.0), (97.0, 1.0)],
+                &[(101.0, 3.0), (102.0, 2.0), (103.0, 1.0)],
+            ))
+            .unwrap();
+        assert!(front_slope >= 0.0);
+        assert!(back_slope > front_slope);
+    }
+
+    #[test]
+    fn known_slope_value() {
+        // Symmetric book, each side: distances 1, 2; cumulative sizes 1, 3.
+        // OLS slope of (1->1, 2->3) = 2. Mean of two equal sides = 2.
+        let mut ds = DepthSlope::new();
+        let out = ds
+            .update(book(
+                &[(99.0, 1.0), (98.0, 2.0)],
+                &[(101.0, 1.0), (102.0, 2.0)],
+            ))
+            .unwrap();
+        assert!((out - 2.0).abs() < 1e-9);
+    }
+
+    #[test]
+    fn single_level_side_is_zero() {
+        let mut ds = DepthSlope::new();
+        // Bid side has only one level -> no slope -> 0.
+        assert_eq!(
+            ds.update(book(&[(100.0, 1.0)], &[(101.0, 1.0), (102.0, 1.0)])),
+            Some(0.0)
+        );
+    }
+
+    #[test]
+    fn empty_book_is_zero() {
+        let mut ds = DepthSlope::new();
+        assert_eq!(
+            ds.update(OrderBook::new_unchecked(vec![], vec![])),
+            Some(0.0)
+        );
+    }
+
+    #[test]
+    fn degenerate_distance_slope_is_zero() {
+        // Two levels at the same distance from mid carry zero x-variance.
+        let levels = [
+            Level::new_unchecked(100.0, 1.0),
+            Level::new_unchecked(100.0, 2.0),
+        ];
+        assert_eq!(cumulative_slope(&levels, 100.0, 1.0), 0.0);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let books: Vec<OrderBook> = (0..20)
+            .map(|i| {
+                let extra = f64::from(i % 4);
+                book(
+                    &[(99.0, 1.0 + extra), (98.0, 2.0)],
+                    &[(101.0, 1.0), (102.0, 2.0 + extra)],
+                )
+            })
+            .collect();
+        let mut a = DepthSlope::new();
+        let mut b = DepthSlope::new();
+        assert_eq!(
+            a.batch(&books),
+            books
+                .iter()
+                .map(|x| b.update(x.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut ds = DepthSlope::new();
+        ds.update(book(
+            &[(99.0, 1.0), (98.0, 2.0)],
+            &[(101.0, 1.0), (102.0, 2.0)],
+        ));
+        assert!(ds.is_ready());
+        ds.reset();
+        assert!(!ds.is_ready());
+    }
+}

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

@@ -0,0 +1,235 @@
+//! Gatev distance (sum of squared deviations) between two normalised series.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Sum of squared deviations between two price series, normalised to a common
+/// start — the classic Gatev et al. pairs-selection distance.
+///
+/// Each `update` takes one `(a, b)` price pair. Over the trailing window of
+/// `period` pairs each series is rebased to `1` at the window's first bar and
+/// the squared gap between the two normalised paths is summed:
+///
+/// ```text
+/// ãᵢ = aᵢ / a_first        b̃ᵢ = bᵢ / b_first
+/// SSD = Σ (ãᵢ − b̃ᵢ)²
+/// ```
+///
+/// Rebasing puts the two series on the same scale (both start at `1`), so the
+/// distance measures how far their *relative* paths drift apart. A **small**
+/// SSD means the two assets track each other tightly — the screen Gatev,
+/// Goetzmann and Rouwenhorst use to pick tradeable pairs; a large SSD means
+/// they have decoupled. The output is always `≥ 0`. If either series is `0` at
+/// the start of the window the normalisation is undefined and the indicator
+/// returns `0`.
+///
+/// Each `update` is `O(period)`, bounded by the fixed window.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DistanceSsd, Indicator};
+///
+/// let mut d = DistanceSsd::new(20).unwrap();
+/// let mut last = None;
+/// for t in 0..40 {
+///     let base = 100.0 + f64::from(t);
+///     // Two near-identical paths ⇒ tiny distance.
+///     last = d.update((base, base * 1.0001));
+/// }
+/// assert!(last.unwrap() < 1e-3);
+/// ```
+#[derive(Debug, Clone)]
+pub struct DistanceSsd {
+    period: usize,
+    window: VecDeque<(f64, f64)>,
+}
+
+impl DistanceSsd {
+    /// Construct a new Gatev distance estimator.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2` — a distance needs at
+    /// least two points.
+    pub fn new(period: usize) -> Result<Self> {
+        if period < 2 {
+            return Err(Error::InvalidPeriod {
+                message: "distance SSD needs period >= 2",
+            });
+        }
+        Ok(Self {
+            period,
+            window: VecDeque::with_capacity(period),
+        })
+    }
+
+    /// Configured look-back window.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for DistanceSsd {
+    type Input = (f64, f64);
+    type Output = f64;
+
+    fn update(&mut self, input: (f64, f64)) -> Option<f64> {
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(input);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let &(a_first, b_first) = self.window.front().expect("window is full");
+        if a_first == 0.0 || b_first == 0.0 {
+            // Cannot rebase a series that starts at zero.
+            return Some(0.0);
+        }
+        let ssd = self
+            .window
+            .iter()
+            .map(|&(a, b)| {
+                let gap = a / a_first - b / b_first;
+                gap * gap
+            })
+            .sum();
+        Some(ssd)
+    }
+
+    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 {
+        "DistanceSsd"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_period_below_two() {
+        assert!(DistanceSsd::new(1).is_err());
+        assert!(DistanceSsd::new(2).is_ok());
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let d = DistanceSsd::new(20).unwrap();
+        assert_eq!(d.period(), 20);
+        assert_eq!(d.warmup_period(), 20);
+        assert_eq!(d.name(), "DistanceSsd");
+        assert!(!d.is_ready());
+    }
+
+    #[test]
+    fn warmup_returns_none() {
+        let mut d = DistanceSsd::new(3).unwrap();
+        assert_eq!(d.update((1.0, 1.0)), None);
+        assert_eq!(d.update((2.0, 2.0)), None);
+        assert!(d.update((3.0, 3.0)).is_some());
+        assert!(d.is_ready());
+    }
+
+    #[test]
+    fn identical_normalised_paths_have_zero_distance() {
+        // b = 2·a ⇒ both rebase to the same path ⇒ SSD = 0.
+        let pairs: Vec<(f64, f64)> = (0..20)
+            .map(|t| {
+                let a = 100.0 + f64::from(t);
+                (a, 2.0 * a)
+            })
+            .collect();
+        let last = DistanceSsd::new(10)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn diverging_paths_have_positive_distance() {
+        let pairs: Vec<(f64, f64)> = (0..20)
+            .map(|t| (100.0 + f64::from(t), 100.0 + 3.0 * f64::from(t)))
+            .collect();
+        let last = DistanceSsd::new(10)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert!(last > 0.0, "ssd {last}");
+    }
+
+    #[test]
+    fn hand_computed_value() {
+        // Window of three pairs, a_first = b_first = 1:
+        //   (1,1) → 0; (2,4) → (2−4)² = 4; (3,9) → (3−9)² = 36 ⇒ SSD = 40.
+        let pairs = [(1.0, 1.0), (2.0, 4.0), (3.0, 9.0)];
+        let last = DistanceSsd::new(3)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, 40.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn zero_start_returns_zero() {
+        // First bar of the window has a = 0 ⇒ rebasing undefined ⇒ 0.
+        let pairs = [(0.0, 1.0), (2.0, 2.0), (3.0, 3.0)];
+        let last = DistanceSsd::new(3)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_eq!(last, 0.0);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut d = DistanceSsd::new(4).unwrap();
+        d.batch(&[(1.0, 1.0), (2.0, 2.0), (3.0, 4.0), (4.0, 5.0), (5.0, 6.0)]);
+        assert!(d.is_ready());
+        d.reset();
+        assert!(!d.is_ready());
+        assert_eq!(d.update((1.0, 1.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let pairs: Vec<(f64, f64)> = (0..60)
+            .map(|t| {
+                let a = 100.0 + f64::from(t);
+                (a, 100.0 + 1.2 * f64::from(t) + (f64::from(t) * 0.5).sin())
+            })
+            .collect();
+        let batch = DistanceSsd::new(15).unwrap().batch(&pairs);
+        let mut d = DistanceSsd::new(15).unwrap();
+        let streamed: Vec<_> = pairs.iter().map(|p| d.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

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

@@ -16,22 +16,44 @@ use crate::traits::Indicator;
 /// doji  = body <= body_threshold * range
 /// ```
 ///
-/// The output is `+1.0` when a Doji is detected and `0.0` otherwise. Doji is
-/// directionless — no `−1.0` is emitted. Pattern-shape check only — no trend
-/// filter is applied; combine with a trend indicator for actionable signals.
+/// # Signed ±1 encoding
+///
+/// By default the output is `+1.0` when a Doji is detected and `0.0`
+/// otherwise — a direction-less detection flag. For a drop-in machine-learning
+/// feature where every candlestick pattern shares the same sign convention
+/// (`+1.0` bullish, `−1.0` bearish, `0.0` none), switch the detector into
+/// signed mode with [`Doji::signed`]. A detected Doji is then classified by
+/// where its (negligible) body sits within the bar's range:
+///
+/// ```text
+/// pos = (0.5 * (open + close) − low) / (high − low)
+/// pos > 2/3  ->  +1.0   dragonfly  (long lower shadow, bullish)
+/// pos < 1/3  ->  −1.0   gravestone (long upper shadow, bearish)
+/// else       ->   0.0   long-legged / standard (neutral)
+/// ```
+///
+/// Pattern-shape check only — no trend filter is applied; combine with a trend
+/// indicator for actionable signals.
 ///
 /// # Example
 ///
 /// ```
 /// use wickra_core::{Candle, Doji, Indicator};
 ///
+/// // Default: direction-less detection flag.
 /// let mut indicator = Doji::default();
 /// let candle = Candle::new(10.0, 11.0, 9.0, 10.0, 1.0, 0).unwrap();
 /// assert_eq!(indicator.update(candle), Some(1.0));
+///
+/// // Signed: a dragonfly Doji (body at the top, long lower shadow) is bullish.
+/// let mut signed = Doji::new().signed();
+/// let dragonfly = Candle::new(10.0, 10.05, 6.0, 10.0, 1.0, 0).unwrap();
+/// assert_eq!(signed.update(dragonfly), Some(1.0));
 /// ```
 #[derive(Debug, Clone)]
 pub struct Doji {
     body_threshold: f64,
+    signed: bool,
     has_emitted: bool,
 }
 
@@ -46,6 +68,7 @@ impl Doji {
     pub const fn new() -> Self {
         Self {
             body_threshold: 0.1,
+            signed: false,
             has_emitted: false,
         }
     }
@@ -61,14 +84,32 @@ impl Doji {
         }
         Ok(Self {
             body_threshold,
+            signed: false,
             has_emitted: false,
         })
     }
 
+    /// Switch to the signed dragonfly / gravestone encoding (consuming builder).
+    ///
+    /// In signed mode a detected Doji emits `+1.0` (dragonfly, bullish),
+    /// `−1.0` (gravestone, bearish) or `0.0` (long-legged / neutral) instead of
+    /// the default direction-less `+1.0` detection flag. See the type-level
+    /// docs for the exact classification rule.
+    #[must_use]
+    pub fn signed(mut self) -> Self {
+        self.signed = true;
+        self
+    }
+
     /// Configured body / range threshold.
     pub fn body_threshold(&self) -> f64 {
         self.body_threshold
     }
+
+    /// Whether this detector emits the signed dragonfly / gravestone encoding.
+    pub fn is_signed(&self) -> bool {
+        self.signed
+    }
 }
 
 impl Indicator for Doji {
@@ -82,11 +123,23 @@ impl Indicator for Doji {
             return Some(0.0);
         }
         let body = (candle.close - candle.open).abs();
-        Some(if body <= self.body_threshold * range {
-            1.0
+        if body > self.body_threshold * range {
+            return Some(0.0);
+        }
+        if !self.signed {
+            return Some(1.0);
+        }
+        // Signed mode: classify the Doji by where its (negligible) body sits
+        // within the high–low range.
+        let body_mid = 0.5 * (candle.open + candle.close);
+        let pos = (body_mid - candle.low) / range;
+        if pos > 2.0 / 3.0 {
+            Some(1.0)
+        } else if pos < 1.0 / 3.0 {
+            Some(-1.0)
         } else {
-            0.0
-        })
+            Some(0.0)
+        }
     }
 
     fn reset(&mut self) {
@@ -134,6 +187,7 @@ mod tests {
         assert_eq!(d.name(), "Doji");
         assert_eq!(d.warmup_period(), 1);
         assert!(!d.is_ready());
+        assert!(!d.is_signed());
         assert!((d.body_threshold() - 0.1).abs() < 1e-12);
     }
 
@@ -182,4 +236,81 @@ mod tests {
         d.reset();
         assert!(!d.is_ready());
     }
+
+    #[test]
+    fn signed_accessor_and_builder() {
+        let d = Doji::new().signed();
+        assert!(d.is_signed());
+        // The consuming builder composes with `with_threshold`.
+        let t = Doji::with_threshold(0.05).unwrap().signed();
+        assert!(t.is_signed());
+        assert!((t.body_threshold() - 0.05).abs() < 1e-12);
+    }
+
+    #[test]
+    fn signed_dragonfly_is_plus_one() {
+        // Body at the top of the range, long lower shadow -> bullish.
+        let mut d = Doji::new().signed();
+        assert_eq!(d.update(c(10.0, 10.05, 6.0, 10.0, 0)), Some(1.0));
+    }
+
+    #[test]
+    fn signed_gravestone_is_minus_one() {
+        // Body at the bottom of the range, long upper shadow -> bearish.
+        let mut d = Doji::new().signed();
+        assert_eq!(d.update(c(10.0, 14.0, 9.95, 10.0, 0)), Some(-1.0));
+    }
+
+    #[test]
+    fn signed_long_legged_is_zero() {
+        // Body centred, symmetric shadows -> neutral.
+        let mut d = Doji::new().signed();
+        assert_eq!(d.update(c(10.0, 12.0, 8.0, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn signed_non_doji_is_zero() {
+        // A large body is not a Doji at all -> 0 regardless of position.
+        let mut d = Doji::new().signed();
+        assert_eq!(d.update(c(10.0, 12.0, 10.0, 12.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn signed_zero_range_is_zero() {
+        let mut d = Doji::new().signed();
+        assert_eq!(d.update(c(10.0, 10.0, 10.0, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn signed_batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + i as f64;
+                // Alternate dragonfly / gravestone / centred Doji shapes.
+                match i % 3 {
+                    0 => c(base, base + 0.05, base - 4.0, base, i),
+                    1 => c(base, base + 4.0, base - 0.05, base, i),
+                    _ => c(base, base + 2.0, base - 2.0, base, i),
+                }
+            })
+            .collect();
+        let mut a = Doji::new().signed();
+        let mut b = Doji::new().signed();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn signed_survives_reset() {
+        let mut d = Doji::new().signed();
+        d.update(c(10.0, 10.05, 6.0, 10.0, 0));
+        assert!(d.is_ready());
+        d.reset();
+        assert!(!d.is_ready());
+        // `reset` clears only the streaming state, not the signed configuration.
+        assert!(d.is_signed());
+        assert_eq!(d.update(c(10.0, 10.05, 6.0, 10.0, 1)), Some(1.0));
+    }
 }

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

@@ -0,0 +1,213 @@
+//! Doji Star candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Doji Star — a 2-bar reversal warning. A long trending body is followed by a
+/// doji whose tiny body gaps away in the direction of the trend, the indecision
+/// hinting the move is about to turn.
+///
+/// ```text
+/// long body  = |close − open| >= 0.5 * (high − low)        (bar1)
+/// doji       = |close − open| <= 0.1 * (high − low)        (bar2)
+/// bullish (+1.0): bar1 black, doji body gaps DOWN below it  (max(o2,c2) < close1)
+/// bearish (−1.0): bar1 white, doji body gaps UP above it    (min(o2,c2) > close1)
+/// ```
+///
+/// Output is `+1.0` (bullish star, after a black bar) or `−1.0` (bearish star,
+/// after a white bar) when the pattern completes, and `0.0` otherwise. The first
+/// bar always returns `0.0` because the two-bar window is not yet filled. Doji
+/// thresholds follow the geometric house style (fixed half-range body for the
+/// long bar, tenth-range body for the doji) 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, `−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, DojiStar, Indicator};
+///
+/// let mut indicator = DojiStar::new();
+/// // Long black bar, then a doji gapping down -> bullish star.
+/// indicator.update(Candle::new(20.0, 20.2, 14.8, 15.0, 1.0, 0).unwrap());
+/// let out = indicator
+///     .update(Candle::new(13.0, 13.1, 12.9, 13.0, 1.0, 1).unwrap());
+/// assert_eq!(out, Some(1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct DojiStar {
+    prev: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl DojiStar {
+    /// Construct a new Doji Star detector.
+    pub const fn new() -> Self {
+        Self {
+            prev: None,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for DojiStar {
+    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;
+        if range1 <= 0.0 || range2 <= 0.0 {
+            return Some(0.0);
+        }
+        let body1 = bar1.close - bar1.open;
+        if body1.abs() < 0.5 * range1 {
+            return Some(0.0);
+        }
+        if (candle.close - candle.open).abs() > 0.1 * range2 {
+            return Some(0.0);
+        }
+        let doji_top = candle.open.max(candle.close);
+        let doji_bottom = candle.open.min(candle.close);
+        // Bullish: long black bar, doji body gaps down below it.
+        if body1 < 0.0 && doji_top < bar1.close {
+            return Some(1.0);
+        }
+        // Bearish: long white bar, doji body gaps up above it.
+        if body1 > 0.0 && doji_bottom > bar1.close {
+            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 {
+        "DojiStar"
+    }
+}
+
+#[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 = DojiStar::new();
+        assert_eq!(t.name(), "DojiStar");
+        assert_eq!(t.warmup_period(), 2);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn bullish_doji_star_is_plus_one() {
+        let mut t = DojiStar::new();
+        assert_eq!(t.update(c(20.0, 20.2, 14.8, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(13.0, 13.1, 12.9, 13.0, 1)), Some(1.0));
+    }
+
+    #[test]
+    fn bearish_doji_star_is_minus_one() {
+        let mut t = DojiStar::new();
+        assert_eq!(t.update(c(15.0, 20.2, 14.8, 20.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(22.0, 22.1, 21.9, 22.0, 1)), Some(-1.0));
+    }
+
+    #[test]
+    fn second_bar_not_doji_yields_zero() {
+        let mut t = DojiStar::new();
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        // Wide body, not a doji.
+        assert_eq!(t.update(c(13.0, 13.2, 11.0, 11.5, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn no_gap_yields_zero() {
+        let mut t = DojiStar::new();
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        // Doji overlaps bar1's body (no gap down).
+        assert_eq!(t.update(c(16.0, 16.1, 15.9, 16.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn short_first_body_yields_zero() {
+        let mut t = DojiStar::new();
+        // First bar body too short to be the "long" leg.
+        t.update(c(20.0, 24.0, 16.0, 19.5, 0));
+        assert_eq!(t.update(c(13.0, 13.1, 12.9, 13.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn first_bar_returns_zero() {
+        let mut t = DojiStar::new();
+        assert_eq!(t.update(c(20.0, 20.2, 14.8, 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;
+                if i % 2 == 0 {
+                    c(base + 5.0, base + 5.2, base - 0.2, base, i)
+                } else {
+                    c(base - 3.0, base - 2.9, base - 3.1, base - 3.0, i)
+                }
+            })
+            .collect();
+        let mut a = DojiStar::new();
+        let mut b = DojiStar::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = DojiStar::new();
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        t.update(c(13.0, 13.1, 12.9, 13.0, 1));
+        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));
+    }
+
+    #[test]
+    fn zero_range_yields_zero() {
+        let mut t = DojiStar::new();
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        // Flat second bar (high == low) -> zero-range guard.
+        assert_eq!(t.update(c(13.0, 13.0, 13.0, 13.0, 1)), Some(0.0));
+    }
+}

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

@@ -0,0 +1,210 @@
+//! Downside Gap Three Methods candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Downside Gap Three Methods — a 3-bar bearish continuation. Two black candles
+/// decline with a downside body gap between them, then a white candle opens inside
+/// the second body and closes inside the first body, partially filling the gap
+/// without erasing the prior decline.
+///
+/// ```text
+/// bar1 black, bar2 black
+/// downside body gap: open2 < close1   (bar2's body sits entirely below bar1's)
+/// bar3 white, opens within bar2's body and closes within bar1's body
+/// ```
+///
+/// Output is `−1.0` when the pattern completes and `0.0` otherwise. Downside Gap
+/// Three Methods is a single-direction (bearish-only) continuation, so it never
+/// emits `+1.0`; its bullish mirror is [`crate::UpsideGapThreeMethods`]. 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::{Candle, DownsideGapThreeMethods, Indicator};
+///
+/// let mut indicator = DownsideGapThreeMethods::new();
+/// indicator.update(Candle::new(13.0, 13.2, 11.8, 12.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(11.0, 11.1, 9.8, 10.0, 1.0, 1).unwrap());
+/// let out = indicator
+///     .update(Candle::new(10.5, 12.6, 10.4, 12.5, 1.0, 2).unwrap());
+/// assert_eq!(out, Some(-1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct DownsideGapThreeMethods {
+    c1: Option<Candle>,
+    c2: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl DownsideGapThreeMethods {
+    /// Construct a new Downside Gap Three Methods detector.
+    pub const fn new() -> Self {
+        Self {
+            c1: None,
+            c2: None,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for DownsideGapThreeMethods {
+    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;
+        self.c1 = self.c2;
+        self.c2 = Some(candle);
+        let (Some(bar1), Some(bar2)) = (bar1, bar2) else {
+            return Some(0.0);
+        };
+        // bar1 and bar2 are both black.
+        if bar1.close >= bar1.open || bar2.close >= bar2.open {
+            return Some(0.0);
+        }
+        // Downside body gap: bar2's body sits entirely below bar1's.
+        if bar2.open >= bar1.close {
+            return Some(0.0);
+        }
+        // bar3 is white.
+        if candle.close <= candle.open {
+            return Some(0.0);
+        }
+        // bar3 opens within bar2's body and closes within bar1's body.
+        if candle.open > bar2.close
+            && candle.open < bar2.open
+            && candle.close > bar1.close
+            && candle.close < bar1.open
+        {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.c1 = None;
+        self.c2 = None;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        3
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "DownsideGapThreeMethods"
+    }
+}
+
+#[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 = DownsideGapThreeMethods::new();
+        assert_eq!(t.name(), "DownsideGapThreeMethods");
+        assert_eq!(t.warmup_period(), 3);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn downside_gap_three_methods_is_minus_one() {
+        let mut t = DownsideGapThreeMethods::new();
+        assert_eq!(t.update(c(13.0, 13.2, 11.8, 12.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 11.1, 9.8, 10.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(10.5, 12.6, 10.4, 12.5, 2)), Some(-1.0));
+    }
+
+    #[test]
+    fn first_two_bars_return_zero() {
+        let mut t = DownsideGapThreeMethods::new();
+        assert_eq!(t.update(c(13.0, 13.2, 11.8, 12.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 11.1, 9.8, 10.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn non_black_first_bars_yield_zero() {
+        let mut t = DownsideGapThreeMethods::new();
+        // bar1 is white.
+        t.update(c(11.0, 13.2, 10.8, 13.0, 0));
+        t.update(c(11.0, 11.1, 9.8, 10.0, 1));
+        assert_eq!(t.update(c(10.5, 12.6, 10.4, 12.5, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn no_gap_yields_zero() {
+        let mut t = DownsideGapThreeMethods::new();
+        t.update(c(13.0, 13.2, 11.8, 12.0, 0));
+        // bar2 opens above bar1's close -> no downside body gap.
+        t.update(c(12.5, 12.6, 11.4, 11.5, 1));
+        assert_eq!(t.update(c(11.5, 12.6, 11.4, 12.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn third_bar_not_white_yields_zero() {
+        let mut t = DownsideGapThreeMethods::new();
+        t.update(c(13.0, 13.2, 11.8, 12.0, 0));
+        t.update(c(11.0, 11.1, 9.8, 10.0, 1));
+        // bar3 black.
+        assert_eq!(t.update(c(12.5, 12.6, 10.4, 10.5, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn third_bar_outside_bodies_yields_zero() {
+        let mut t = DownsideGapThreeMethods::new();
+        t.update(c(13.0, 13.2, 11.8, 12.0, 0));
+        t.update(c(11.0, 11.1, 9.8, 10.0, 1));
+        // bar3 white but closes above bar1's body.
+        assert_eq!(t.update(c(10.5, 14.0, 10.4, 13.5, 2)), 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.1, base - 5.2, base - 5.0, i)
+            })
+            .collect();
+        let mut a = DownsideGapThreeMethods::new();
+        let mut b = DownsideGapThreeMethods::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = DownsideGapThreeMethods::new();
+        t.update(c(13.0, 13.2, 11.8, 12.0, 0));
+        t.update(c(11.0, 11.1, 9.8, 10.0, 1));
+        t.update(c(10.5, 12.6, 10.4, 12.5, 2));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(13.0, 13.2, 11.8, 12.0, 0)), Some(0.0));
+    }
+}

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

@@ -0,0 +1,163 @@
+//! Dragonfly Doji candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Dragonfly Doji — a single-bar bullish reversal. Open, close, and high sit at
+/// the top of the bar while a long lower shadow shows price was driven down hard
+/// and then bid all the way back to the open — buyers rejecting the lows.
+///
+/// ```text
+/// range = high − low
+/// doji         = |close − open| <= 0.1 * range
+/// no upper wick = high − max(open, close) <= 0.1 * range
+/// long lower    = min(open, close) − low   >= 0.5 * range
+/// ```
+///
+/// Output is `+1.0` when the dragonfly prints and `0.0` otherwise. Dragonfly Doji
+/// is a single-direction (bullish-only) shape, so it never emits `−1.0`. Body and
+/// shadow thresholds follow the geometric house style (fixed fractions of the bar
+/// range) 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, DragonflyDoji, Indicator};
+///
+/// let mut indicator = DragonflyDoji::new();
+/// // Body at the top, long lower shadow.
+/// let candle = Candle::new(10.0, 10.05, 6.0, 10.0, 1.0, 0).unwrap();
+/// assert_eq!(indicator.update(candle), Some(1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct DragonflyDoji {
+    has_emitted: bool,
+}
+
+impl DragonflyDoji {
+    /// Construct a new Dragonfly Doji detector.
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for DragonflyDoji {
+    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);
+        }
+        if (candle.close - candle.open).abs() > 0.1 * range {
+            return Some(0.0);
+        }
+        let upper = candle.high - candle.open.max(candle.close);
+        let lower = candle.open.min(candle.close) - candle.low;
+        if upper <= 0.1 * range && lower >= 0.5 * range {
+            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 {
+        "DragonflyDoji"
+    }
+}
+
+#[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 = DragonflyDoji::new();
+        assert_eq!(t.name(), "DragonflyDoji");
+        assert_eq!(t.warmup_period(), 1);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn dragonfly_is_plus_one() {
+        let mut t = DragonflyDoji::new();
+        assert_eq!(t.update(c(10.0, 10.05, 6.0, 10.0, 0)), Some(1.0));
+    }
+
+    #[test]
+    fn upper_shadow_yields_zero() {
+        let mut t = DragonflyDoji::new();
+        // Long upper shadow -> not a dragonfly (this is a gravestone shape).
+        assert_eq!(t.update(c(10.0, 14.0, 9.95, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn short_lower_shadow_yields_zero() {
+        let mut t = DragonflyDoji::new();
+        // Body at the top but the lower shadow is too short.
+        assert_eq!(t.update(c(10.0, 10.05, 9.6, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn non_doji_yields_zero() {
+        let mut t = DragonflyDoji::new();
+        assert_eq!(t.update(c(10.0, 12.0, 6.0, 11.5, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn zero_range_yields_zero() {
+        let mut t = DragonflyDoji::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 + 0.05, base - 4.0, base, i)
+            })
+            .collect();
+        let mut a = DragonflyDoji::new();
+        let mut b = DragonflyDoji::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = DragonflyDoji::new();
+        t.update(c(10.0, 10.05, 6.0, 10.0, 0));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+    }
+}

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

@@ -0,0 +1,232 @@
+//! Directional Movement Index (DX), Wilder-smoothed.
+
+use crate::error::{Error, Result};
+use crate::indicators::adx::directional_movement;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Wilder's Directional Movement Index (`DX`).
+///
+/// `DX = 100 · |+DI − −DI| / (+DI + −DI)`, the un-smoothed precursor to
+/// [`Adx`](crate::Adx) (which is the Wilder average of `DX`). Both directional
+/// indicators are derived from Wilder-smoothed `+DM`, `−DM` and true range over
+/// `period` bars, so the first value is emitted after `period + 1` candles.
+///
+/// `DX` ranges over `[0, 100]`: high when one side of the directional system
+/// clearly dominates (a strong trend) and near zero when `+DI` and `−DI` are
+/// balanced (a range). When both directional indicators are zero — a perfectly
+/// flat market — the index returns `0`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, Dx};
+///
+/// let mut indicator = Dx::new(5).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 Dx {
+    period: usize,
+    prev: Option<Candle>,
+    plus_dm_seed: f64,
+    minus_dm_seed: f64,
+    tr_seed: f64,
+    seed_count: usize,
+    plus_dm_smooth: Option<f64>,
+    minus_dm_smooth: Option<f64>,
+    tr_smooth: Option<f64>,
+}
+
+impl Dx {
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            prev: None,
+            plus_dm_seed: 0.0,
+            minus_dm_seed: 0.0,
+            tr_seed: 0.0,
+            seed_count: 0,
+            plus_dm_smooth: None,
+            minus_dm_smooth: None,
+            tr_smooth: None,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for Dx {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let Some(prev) = self.prev else {
+            self.prev = Some(candle);
+            return None;
+        };
+        self.prev = Some(candle);
+
+        let (plus_dm, minus_dm) = directional_movement(&prev, &candle);
+        let tr = candle.true_range(Some(prev.close));
+        let n = self.period as f64;
+
+        let (plus_v, minus_v, tr_v) = if let (Some(p), Some(m), Some(t)) =
+            (self.plus_dm_smooth, self.minus_dm_smooth, self.tr_smooth)
+        {
+            let p_new = p - p / n + plus_dm;
+            let m_new = m - m / n + minus_dm;
+            let t_new = t - t / n + tr;
+            self.plus_dm_smooth = Some(p_new);
+            self.minus_dm_smooth = Some(m_new);
+            self.tr_smooth = Some(t_new);
+            (p_new, m_new, t_new)
+        } else {
+            self.plus_dm_seed += plus_dm;
+            self.minus_dm_seed += minus_dm;
+            self.tr_seed += tr;
+            self.seed_count += 1;
+            if self.seed_count < self.period {
+                return None;
+            }
+            self.plus_dm_smooth = Some(self.plus_dm_seed);
+            self.minus_dm_smooth = Some(self.minus_dm_seed);
+            self.tr_smooth = Some(self.tr_seed);
+            (self.plus_dm_seed, self.minus_dm_seed, self.tr_seed)
+        };
+
+        let (plus_di, minus_di) = if tr_v == 0.0 {
+            (0.0, 0.0)
+        } else {
+            (100.0 * plus_v / tr_v, 100.0 * minus_v / tr_v)
+        };
+        let di_sum = plus_di + minus_di;
+        let dx = if di_sum == 0.0 {
+            0.0
+        } else {
+            100.0 * (plus_di - minus_di).abs() / di_sum
+        };
+        Some(dx)
+    }
+
+    fn reset(&mut self) {
+        self.prev = None;
+        self.plus_dm_seed = 0.0;
+        self.minus_dm_seed = 0.0;
+        self.tr_seed = 0.0;
+        self.seed_count = 0;
+        self.plus_dm_smooth = None;
+        self.minus_dm_smooth = None;
+        self.tr_smooth = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.tr_smooth.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "DX"
+    }
+}
+
+#[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!(Dx::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_report_config() {
+        let dx = Dx::new(7).unwrap();
+        assert_eq!(dx.period(), 7);
+        assert_eq!(dx.name(), "DX");
+        assert_eq!(dx.warmup_period(), 7);
+        assert!(!dx.is_ready());
+    }
+
+    #[test]
+    fn strong_trend_drives_dx_high() {
+        // A clean uptrend has one-sided directional movement, so DX is large.
+        let candles: Vec<Candle> = (0..12)
+            .map(|i| {
+                let base = 100.0 + f64::from(i) * 2.0;
+                c(base + 1.0, base - 0.5, base + 0.5)
+            })
+            .collect();
+        let mut dx = Dx::new(3).unwrap();
+        let out: Vec<Option<f64>> = dx.batch(&candles);
+        assert_eq!(out[0], None);
+        assert!(out[3].is_some());
+        let last = out.into_iter().flatten().last().unwrap();
+        assert!(last > 50.0 && last <= 100.0);
+        assert!(dx.is_ready());
+    }
+
+    #[test]
+    fn flat_market_returns_zero() {
+        // Both directional indicators collapse to zero -> DX is zero.
+        let candles: Vec<Candle> = (0..6).map(|_| c(50.0, 50.0, 50.0)).collect();
+        let mut dx = Dx::new(3).unwrap();
+        let last = dx.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_relative_eq!(last, 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn balanced_directional_movement_is_low() {
+        // Alternating up and down bars of equal magnitude keep +DI and -DI close,
+        // so DX stays well below a trending reading.
+        let candles: Vec<Candle> = (0..30)
+            .map(|i| {
+                let base = if i % 2 == 0 { 100.0 } else { 101.0 };
+                c(base + 1.0, base - 1.0, base)
+            })
+            .collect();
+        let mut dx = Dx::new(5).unwrap();
+        let last = dx.batch(&candles).into_iter().flatten().last().unwrap();
+        assert!((0.0..=100.0).contains(&last));
+    }
+
+    #[test]
+    fn reset_restores_initial_state() {
+        let candles: Vec<Candle> = (0..6)
+            .map(|i| {
+                let base = 100.0 + f64::from(i) * 2.0;
+                c(base + 1.0, base - 0.5, base + 0.5)
+            })
+            .collect();
+        let mut dx = Dx::new(3).unwrap();
+        let _ = dx.batch(&candles);
+        assert!(dx.is_ready());
+        dx.reset();
+        assert!(!dx.is_ready());
+        assert_eq!(dx.update(candles[0]), None);
+    }
+}

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

@@ -0,0 +1,157 @@
+//! Effective Spread — the realised cost of a single trade in basis points.
+
+use crate::microstructure::TradeQuote;
+use crate::traits::Indicator;
+
+/// Effective Spread — twice the signed deviation of an executed trade price
+/// from the prevailing mid, expressed in basis points of the mid.
+///
+/// ```text
+/// effectiveSpread = 2 · D · (tradePrice − mid) / mid · 10_000   (bps)
+/// ```
+///
+/// where `D` is the aggressor sign (`+1` for a buy, `−1` for a sell). The
+/// factor of two scales the one-sided deviation up to a full round-trip cost so
+/// it is directly comparable to the [quoted spread]: a marketable order that
+/// fills exactly at the touch of an otherwise quoted-spread book pays an
+/// effective spread equal to the quoted spread. Trades that fill *inside* the
+/// spread (price improvement) read below the quoted spread; trades that walk
+/// the book read above it.
+///
+/// A buy printed above the mid (`tradePrice > mid`) and a sell printed below it
+/// both yield a positive effective spread — the conventional sign, since the
+/// aggressor pays in both cases. A trade printed on the wrong side of the mid
+/// for its aggressor flag (a buy below the mid) reads negative, the signature of
+/// price improvement or a stale/mislabelled quote.
+///
+/// `Input = TradeQuote`, `Output = f64`. Stateless; ready after the first
+/// trade-quote.
+///
+/// [quoted spread]: crate::QuotedSpread
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{EffectiveSpread, Indicator, Side, Trade, TradeQuote};
+///
+/// let mut es = EffectiveSpread::new();
+/// // Buy filled at 100.05 against a mid of 100.0:
+/// // 2 · (+1) · (100.05 − 100.0) / 100.0 · 10_000 = 10 bps.
+/// let trade = Trade::new(100.05, 1.0, Side::Buy, 0).unwrap();
+/// let quote = TradeQuote::new(trade, 100.0).unwrap();
+/// assert!((es.update(quote).unwrap() - 10.0).abs() < 1e-9);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct EffectiveSpread {
+    has_emitted: bool,
+}
+
+impl EffectiveSpread {
+    /// Construct a new effective-spread indicator.
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for EffectiveSpread {
+    type Input = TradeQuote;
+    type Output = f64;
+
+    fn update(&mut self, quote: TradeQuote) -> Option<f64> {
+        self.has_emitted = true;
+        let sign = quote.trade.side.sign();
+        Some(2.0 * sign * (quote.trade.price - quote.mid) / quote.mid * 10_000.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 {
+        "EffectiveSpread"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::microstructure::{Side, Trade};
+    use crate::traits::BatchExt;
+
+    fn quote(price: f64, side: Side, mid: f64) -> TradeQuote {
+        TradeQuote::new(Trade::new(price, 1.0, side, 0).unwrap(), mid).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let es = EffectiveSpread::new();
+        assert_eq!(es.name(), "EffectiveSpread");
+        assert_eq!(es.warmup_period(), 1);
+        assert!(!es.is_ready());
+    }
+
+    #[test]
+    fn buy_above_mid_is_positive() {
+        let mut es = EffectiveSpread::new();
+        // 2 · (+1) · (100.05 − 100.0) / 100.0 · 10_000 = 10 bps.
+        let out = es.update(quote(100.05, Side::Buy, 100.0)).unwrap();
+        assert!((out - 10.0).abs() < 1e-9);
+        assert!(es.is_ready());
+    }
+
+    #[test]
+    fn sell_below_mid_is_positive() {
+        let mut es = EffectiveSpread::new();
+        // 2 · (−1) · (99.95 − 100.0) / 100.0 · 10_000 = 10 bps.
+        let out = es.update(quote(99.95, Side::Sell, 100.0)).unwrap();
+        assert!((out - 10.0).abs() < 1e-9);
+    }
+
+    #[test]
+    fn price_improvement_reads_negative() {
+        let mut es = EffectiveSpread::new();
+        // A buy filled below the mid: price improvement -> negative.
+        let out = es.update(quote(99.95, Side::Buy, 100.0)).unwrap();
+        assert!(out < 0.0);
+    }
+
+    #[test]
+    fn trade_at_mid_is_zero() {
+        let mut es = EffectiveSpread::new();
+        assert_eq!(es.update(quote(100.0, Side::Buy, 100.0)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let quotes: Vec<TradeQuote> = (0..20)
+            .map(|i| {
+                let side = if i % 2 == 0 { Side::Buy } else { Side::Sell };
+                let price = 100.0 + f64::from(i % 4) * 0.01;
+                quote(price, side, 100.0)
+            })
+            .collect();
+        let mut a = EffectiveSpread::new();
+        let mut b = EffectiveSpread::new();
+        assert_eq!(
+            a.batch(&quotes),
+            quotes.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut es = EffectiveSpread::new();
+        es.update(quote(100.05, Side::Buy, 100.0));
+        assert!(es.is_ready());
+        es.reset();
+        assert!(!es.is_ready());
+    }
+}

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

@@ -22,6 +22,13 @@ use crate::traits::Indicator;
 /// body exists to engulf. Pattern-shape check only — no trend filter is
 /// applied; combine with a trend indicator for actionable signals.
 ///
+/// # Signed ±1 encoding
+///
+/// This detector already 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 of the pattern occupy a single dimension.
+///
 /// # Example
 ///
 /// ```

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

@@ -0,0 +1,259 @@
+//! Evening Doji Star candlestick pattern.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Evening Doji Star — a 3-bar bearish top reversal. A long white bar extends the
+/// advance, a doji gaps up above it (the star of indecision), then a black bar
+/// gaps back down and closes deep into the first body, confirming the turn.
+///
+/// ```text
+/// long body = |close − open| >= 0.5 * (high − low)
+/// doji      = |close − open| <= 0.1 * (high − low)
+/// bar1 white & long
+/// bar2 doji, body gaps UP above bar1 body       (min(o2,c2) > close1)
+/// bar3 black, body gaps DOWN below the doji      (max(o3,c3) < min(o2,c2))
+/// bar3 closes deep into bar1 body                (close3 < close1 − penetration·body1)
+/// ```
+///
+/// Output is `−1.0` when the pattern completes and `0.0` otherwise. Evening Doji
+/// Star is a single-direction (bearish-only) reversal, so it never emits `+1.0`.
+/// The first two bars always return `0.0` because the three-bar window is not yet
+/// filled. `penetration` is how far into the first body the third bar must close;
+/// it defaults to `0.3` (TA-Lib's `CDLEVENINGDOJISTAR` default) and must lie in
+/// `[0, 1)`. Body and doji 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` bearish, `0.0` no pattern — so it drops straight into
+/// a machine-learning feature matrix as a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, EveningDojiStar, Indicator};
+///
+/// let mut indicator = EveningDojiStar::new();
+/// indicator.update(Candle::new(10.0, 15.1, 9.9, 15.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(17.0, 17.1, 16.9, 17.0, 1.0, 1).unwrap());
+/// let out = indicator
+///     .update(Candle::new(16.0, 16.1, 11.9, 12.0, 1.0, 2).unwrap());
+/// assert_eq!(out, Some(-1.0));
+/// ```
+#[derive(Debug, Clone)]
+pub struct EveningDojiStar {
+    penetration: f64,
+    prev: Option<Candle>,
+    prev_prev: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl Default for EveningDojiStar {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EveningDojiStar {
+    /// Construct an Evening Doji Star detector with the default 0.3 penetration.
+    pub const fn new() -> Self {
+        Self {
+            penetration: 0.3,
+            prev: None,
+            prev_prev: None,
+            has_emitted: false,
+        }
+    }
+
+    /// Construct an Evening Doji Star detector with a custom penetration fraction.
+    ///
+    /// `penetration` must lie in `[0, 1)`.
+    pub fn with_penetration(penetration: f64) -> Result<Self> {
+        if !(0.0..1.0).contains(&penetration) {
+            return Err(Error::InvalidPeriod {
+                message: "evening doji star penetration must lie in [0, 1)",
+            });
+        }
+        Ok(Self {
+            penetration,
+            prev: None,
+            prev_prev: None,
+            has_emitted: false,
+        })
+    }
+
+    /// Configured penetration fraction.
+    pub fn penetration(&self) -> f64 {
+        self.penetration
+    }
+}
+
+impl Indicator for EveningDojiStar {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let bar1 = self.prev_prev;
+        let bar2 = self.prev;
+        self.prev_prev = self.prev;
+        self.prev = Some(candle);
+        let (Some(bar1), Some(bar2)) = (bar1, bar2) else {
+            return Some(0.0);
+        };
+        let range1 = bar1.high - bar1.low;
+        let range2 = bar2.high - bar2.low;
+        if range1 <= 0.0 || range2 <= 0.0 {
+            return Some(0.0);
+        }
+        let body1 = bar1.close - bar1.open;
+        if body1 < 0.5 * range1 {
+            return Some(0.0); // bar1 must be a long white body
+        }
+        if (bar2.close - bar2.open).abs() > 0.1 * range2 {
+            return Some(0.0); // bar2 must be a doji
+        }
+        let star_bottom = bar2.open.min(bar2.close);
+        let bar3_top = candle.open.max(candle.close);
+        if star_bottom > bar1.close
+            && candle.close < candle.open
+            && bar3_top < star_bottom
+            && candle.close < bar1.close - self.penetration * body1
+        {
+            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 {
+        "EveningDojiStar"
+    }
+}
+
+#[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_penetration() {
+        assert!(EveningDojiStar::with_penetration(-0.01).is_err());
+        assert!(EveningDojiStar::with_penetration(1.0).is_err());
+    }
+
+    #[test]
+    fn accepts_valid_penetration() {
+        let t = EveningDojiStar::with_penetration(0.5).unwrap();
+        assert!((t.penetration() - 0.5).abs() < 1e-12);
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = EveningDojiStar::default();
+        assert_eq!(t.name(), "EveningDojiStar");
+        assert_eq!(t.warmup_period(), 3);
+        assert!(!t.is_ready());
+        assert!((t.penetration() - 0.3).abs() < 1e-12);
+    }
+
+    #[test]
+    fn evening_doji_star_is_minus_one() {
+        let mut t = EveningDojiStar::new();
+        assert_eq!(t.update(c(10.0, 15.1, 9.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(17.0, 17.1, 16.9, 17.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(16.0, 16.1, 11.9, 12.0, 2)), Some(-1.0));
+    }
+
+    #[test]
+    fn middle_not_doji_yields_zero() {
+        let mut t = EveningDojiStar::new();
+        t.update(c(10.0, 15.1, 9.9, 15.0, 0));
+        // Wide-bodied star, not a doji.
+        t.update(c(16.0, 18.1, 15.9, 18.0, 1));
+        assert_eq!(t.update(c(16.0, 16.1, 11.9, 12.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn shallow_close_yields_zero() {
+        let mut t = EveningDojiStar::new();
+        t.update(c(10.0, 15.1, 9.9, 15.0, 0));
+        t.update(c(17.0, 17.1, 16.9, 17.0, 1));
+        // bar3 black but closes at 14.0 -> only 1.0 into the 5.0 body (< 0.3·5).
+        assert_eq!(t.update(c(16.0, 16.1, 13.9, 14.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn first_two_bars_return_zero() {
+        let mut t = EveningDojiStar::new();
+        assert_eq!(t.update(c(10.0, 15.1, 9.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(17.0, 17.1, 16.9, 17.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 + 5.2, base - 0.1, base + 5.0, i)
+            })
+            .collect();
+        let mut a = EveningDojiStar::new();
+        let mut b = EveningDojiStar::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = EveningDojiStar::new();
+        t.update(c(10.0, 15.1, 9.9, 15.0, 0));
+        t.update(c(17.0, 17.1, 16.9, 17.0, 1));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 2));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(10.0, 15.1, 9.9, 15.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn zero_range_yields_zero() {
+        let mut t = EveningDojiStar::new();
+        // Flat first bar (range1 == 0) -> rejected.
+        t.update(c(10.0, 10.0, 10.0, 10.0, 0));
+        t.update(c(17.0, 17.1, 16.9, 17.0, 1));
+        assert_eq!(t.update(c(16.0, 16.1, 11.9, 12.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn short_first_body_yields_zero() {
+        let mut t = EveningDojiStar::new();
+        // bar1 has a wide range but a tiny body -> not a long white body.
+        t.update(c(10.0, 16.0, 9.0, 10.5, 0));
+        t.update(c(17.0, 17.1, 16.9, 17.0, 1));
+        assert_eq!(t.update(c(16.0, 16.1, 11.9, 12.0, 2)), Some(0.0));
+    }
+}

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

@@ -0,0 +1,235 @@
+//! Falling Three Methods candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Falling Three Methods — a 5-bar bearish continuation. A long black candle is
+/// followed by three small bars that drift up but stay inside its range (a brief
+/// rest), then a second long black candle closes below the first, resuming the
+/// decline.
+///
+/// ```text
+/// long body = |close − open| >= 0.5 * (high − low)
+/// bar1 black & long
+/// bar2, bar3, bar4 small bodies, each contained within bar1's high/low range
+/// bar5 black, closing below bar1's close
+/// ```
+///
+/// Output is `−1.0` when the pattern completes and `0.0` otherwise. Falling Three
+/// Methods is a single-direction (bearish-only) continuation, so it never emits
+/// `+1.0`. The first four bars always return `0.0` because the five-bar window is
+/// not yet filled. Body 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` bearish, `0.0` no pattern — so it drops straight into
+/// a machine-learning feature matrix as a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, FallingThreeMethods, Indicator};
+///
+/// let mut indicator = FallingThreeMethods::new();
+/// indicator.update(Candle::new(15.0, 15.1, 9.9, 10.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(11.0, 12.1, 10.9, 12.0, 1.0, 1).unwrap());
+/// indicator.update(Candle::new(11.5, 12.6, 11.4, 12.5, 1.0, 2).unwrap());
+/// indicator.update(Candle::new(12.0, 13.1, 11.9, 13.0, 1.0, 3).unwrap());
+/// let out = indicator
+///     .update(Candle::new(12.5, 12.6, 8.9, 9.0, 1.0, 4).unwrap());
+/// assert_eq!(out, Some(-1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct FallingThreeMethods {
+    c1: Option<Candle>,
+    c2: Option<Candle>,
+    c3: Option<Candle>,
+    c4: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl FallingThreeMethods {
+    /// Construct a new Falling Three Methods detector.
+    pub const fn new() -> Self {
+        Self {
+            c1: None,
+            c2: None,
+            c3: None,
+            c4: None,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for FallingThreeMethods {
+    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);
+        };
+        let range1 = bar1.high - bar1.low;
+        if range1 <= 0.0 {
+            return Some(0.0);
+        }
+        let body1 = bar1.open - bar1.close;
+        if body1 < 0.5 * range1 {
+            return Some(0.0); // bar1 must be a long black body
+        }
+        // The three middle bars stay within bar1's range with smaller bodies.
+        for mid in [bar2, bar3, bar4] {
+            if (mid.close - mid.open).abs() >= body1 || mid.high > bar1.high || mid.low < bar1.low {
+                return Some(0.0);
+            }
+        }
+        // bar5 is a black candle closing below bar1's close.
+        if candle.close < candle.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 {
+        "FallingThreeMethods"
+    }
+}
+
+#[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 = FallingThreeMethods::new();
+        assert_eq!(t.name(), "FallingThreeMethods");
+        assert_eq!(t.warmup_period(), 5);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn falling_three_methods_is_minus_one() {
+        let mut t = FallingThreeMethods::new();
+        assert_eq!(t.update(c(15.0, 15.1, 9.9, 10.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 12.1, 10.9, 12.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(11.5, 12.6, 11.4, 12.5, 2)), Some(0.0));
+        assert_eq!(t.update(c(12.0, 13.1, 11.9, 13.0, 3)), Some(0.0));
+        assert_eq!(t.update(c(12.5, 12.6, 8.9, 9.0, 4)), Some(-1.0));
+    }
+
+    #[test]
+    fn middle_bar_breaks_range_yields_zero() {
+        let mut t = FallingThreeMethods::new();
+        t.update(c(15.0, 15.1, 9.9, 10.0, 0));
+        t.update(c(11.0, 12.1, 10.9, 12.0, 1));
+        // bar3 pokes below bar1's low.
+        t.update(c(11.5, 12.6, 9.0, 12.5, 2));
+        t.update(c(12.0, 13.1, 11.9, 13.0, 3));
+        assert_eq!(t.update(c(12.5, 12.6, 8.9, 9.0, 4)), Some(0.0));
+    }
+
+    #[test]
+    fn bar5_not_new_low_yields_zero() {
+        let mut t = FallingThreeMethods::new();
+        t.update(c(15.0, 15.1, 9.9, 10.0, 0));
+        t.update(c(11.0, 12.1, 10.9, 12.0, 1));
+        t.update(c(11.5, 12.6, 11.4, 12.5, 2));
+        t.update(c(12.0, 13.1, 11.9, 13.0, 3));
+        // bar5 black but closes above bar1's close.
+        assert_eq!(t.update(c(12.5, 12.6, 10.4, 10.5, 4)), Some(0.0));
+    }
+
+    #[test]
+    fn first_four_bars_return_zero() {
+        let mut t = FallingThreeMethods::new();
+        assert_eq!(t.update(c(15.0, 15.1, 9.9, 10.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 12.1, 10.9, 12.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(11.5, 12.6, 11.4, 12.5, 2)), Some(0.0));
+        assert_eq!(t.update(c(12.0, 13.1, 11.9, 13.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 + 5.0, base + 5.1, base - 0.1, base, i)
+            })
+            .collect();
+        let mut a = FallingThreeMethods::new();
+        let mut b = FallingThreeMethods::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = FallingThreeMethods::new();
+        t.update(c(15.0, 15.1, 9.9, 10.0, 0));
+        t.update(c(11.0, 12.1, 10.9, 12.0, 1));
+        t.update(c(11.5, 12.6, 11.4, 12.5, 2));
+        t.update(c(12.0, 13.1, 11.9, 13.0, 3));
+        t.update(c(12.5, 12.6, 8.9, 9.0, 4));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(15.0, 15.1, 9.9, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn zero_range_first_bar_yields_zero() {
+        let mut t = FallingThreeMethods::new();
+        // Flat first bar (range1 == 0) -> rejected.
+        t.update(c(10.0, 10.0, 10.0, 10.0, 0));
+        t.update(c(11.0, 12.1, 10.9, 12.0, 1));
+        t.update(c(11.5, 12.6, 11.4, 12.5, 2));
+        t.update(c(12.0, 13.1, 11.9, 13.0, 3));
+        assert_eq!(t.update(c(12.5, 12.6, 8.9, 9.0, 4)), Some(0.0));
+    }
+
+    #[test]
+    fn short_first_body_yields_zero() {
+        let mut t = FallingThreeMethods::new();
+        // bar1 has a wide range but a tiny body -> not a long black body.
+        t.update(c(10.0, 16.0, 9.0, 10.2, 0));
+        t.update(c(11.0, 12.1, 10.9, 12.0, 1));
+        t.update(c(11.5, 12.6, 11.4, 12.5, 2));
+        t.update(c(12.0, 13.1, 11.9, 13.0, 3));
+        assert_eq!(t.update(c(12.5, 12.6, 8.9, 9.0, 4)), Some(0.0));
+    }
+}

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

@@ -0,0 +1,259 @@
+//! Footprint — buy/sell volume profile per price bucket within a bar.
+
+use std::collections::BTreeMap;
+
+use crate::error::{Error, Result};
+use crate::microstructure::Trade;
+use crate::traits::Indicator;
+
+/// One price bucket of a [`Footprint`]: the buy- and sell-initiated volume that
+/// traded there since the last reset.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct FootprintLevel {
+    /// Bucket price (the bucket index times the tick size).
+    pub price: f64,
+    /// Sell-initiated (bid-hitting) volume traded at this bucket.
+    pub bid_vol: f64,
+    /// Buy-initiated (ask-lifting) volume traded at this bucket.
+    pub ask_vol: f64,
+}
+
+/// The full footprint of a bar: one [`FootprintLevel`] per touched price
+/// bucket, sorted ascending by price.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct FootprintOutput {
+    /// Touched price buckets, lowest price first.
+    pub levels: Vec<FootprintLevel>,
+}
+
+/// Footprint — the buy/sell volume profile of a bar, bucketed by price.
+///
+/// A footprint (a.k.a. bid/ask or volume cluster chart) decomposes the volume
+/// traded within a bar across the price levels at which it printed, splitting
+/// each level into buy-initiated (ask-lifting) and sell-initiated (bid-hitting)
+/// volume. It exposes *where* inside a bar the activity happened and which side
+/// was the aggressor there — the basis for absorption, imbalance and
+/// point-of-control analysis that a single OHLCV bar hides.
+///
+/// Each trade is assigned to the price bucket `round(price / tick_size)`; its
+/// size is added to that bucket's ask volume for a buy and bid volume for a
+/// sell. Every [`update`] returns the complete footprint accumulated since the
+/// last [`reset`], as a [`FootprintOutput`] whose `levels` are sorted ascending
+/// by price. Call [`reset`] at each bar (or session) boundary to start a fresh
+/// footprint.
+///
+/// `Input = Trade`, `Output = FootprintOutput`. Ready after the first trade.
+///
+/// [`update`]: crate::Indicator::update
+/// [`reset`]: crate::Indicator::reset
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Footprint, Indicator, Side, Trade};
+///
+/// let mut fp = Footprint::new(1.0).unwrap();
+/// fp.update(Trade::new(100.2, 2.0, Side::Buy, 0).unwrap());
+/// let out = fp.update(Trade::new(100.7, 3.0, Side::Sell, 1).unwrap()).unwrap();
+/// // Two buckets: 100 (ask 2) and 101 (bid 3).
+/// assert_eq!(out.levels.len(), 2);
+/// assert_eq!(out.levels[0].price, 100.0);
+/// assert_eq!(out.levels[0].ask_vol, 2.0);
+/// assert_eq!(out.levels[1].price, 101.0);
+/// assert_eq!(out.levels[1].bid_vol, 3.0);
+/// ```
+#[derive(Debug, Clone)]
+pub struct Footprint {
+    tick_size: f64,
+    // bucket index -> (bid_vol = sell-initiated, ask_vol = buy-initiated).
+    buckets: BTreeMap<i64, (f64, f64)>,
+    has_emitted: bool,
+}
+
+impl Footprint {
+    /// Construct a footprint with the given price-bucket `tick_size`.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidTick`] if `tick_size` is not a finite, strictly
+    /// positive number.
+    pub fn new(tick_size: f64) -> Result<Self> {
+        if !tick_size.is_finite() || tick_size <= 0.0 {
+            return Err(Error::InvalidTick {
+                message: "footprint tick_size must be finite and positive",
+            });
+        }
+        Ok(Self {
+            tick_size,
+            buckets: BTreeMap::new(),
+            has_emitted: false,
+        })
+    }
+
+    /// The configured price-bucket size.
+    pub const fn tick_size(&self) -> f64 {
+        self.tick_size
+    }
+
+    fn bucket_index(&self, price: f64) -> i64 {
+        // Float-to-int `as` saturates rather than wrapping, so an extreme
+        // price/tick ratio clamps to i64::MIN/MAX instead of misbehaving;
+        // realistic ratios fit comfortably.
+        #[allow(clippy::cast_possible_truncation)]
+        {
+            (price / self.tick_size).round() as i64
+        }
+    }
+
+    fn snapshot(&self) -> FootprintOutput {
+        let levels = self
+            .buckets
+            .iter()
+            .map(|(&index, &(bid_vol, ask_vol))| FootprintLevel {
+                price: index as f64 * self.tick_size,
+                bid_vol,
+                ask_vol,
+            })
+            .collect();
+        FootprintOutput { levels }
+    }
+}
+
+impl Indicator for Footprint {
+    type Input = Trade;
+    type Output = FootprintOutput;
+
+    fn update(&mut self, trade: Trade) -> Option<FootprintOutput> {
+        self.has_emitted = true;
+        let index = self.bucket_index(trade.price);
+        let entry = self.buckets.entry(index).or_insert((0.0, 0.0));
+        if trade.side.sign() > 0.0 {
+            entry.1 += trade.size;
+        } else {
+            entry.0 += trade.size;
+        }
+        Some(self.snapshot())
+    }
+
+    fn reset(&mut self) {
+        self.buckets.clear();
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "Footprint"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::microstructure::Side;
+    use crate::traits::BatchExt;
+
+    fn trade(price: f64, size: f64, side: Side) -> Trade {
+        Trade::new(price, size, side, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_bad_tick_size() {
+        assert!(matches!(
+            Footprint::new(0.0),
+            Err(Error::InvalidTick { .. })
+        ));
+        assert!(matches!(
+            Footprint::new(-1.0),
+            Err(Error::InvalidTick { .. })
+        ));
+        assert!(matches!(
+            Footprint::new(f64::NAN),
+            Err(Error::InvalidTick { .. })
+        ));
+        assert!(Footprint::new(0.5).is_ok());
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let fp = Footprint::new(0.25).unwrap();
+        assert_eq!(fp.name(), "Footprint");
+        assert_eq!(fp.warmup_period(), 1);
+        assert_eq!(fp.tick_size(), 0.25);
+        assert!(!fp.is_ready());
+    }
+
+    #[test]
+    fn buckets_buy_and_sell_volume() {
+        let mut fp = Footprint::new(1.0).unwrap();
+        fp.update(trade(100.2, 2.0, Side::Buy));
+        fp.update(trade(100.7, 3.0, Side::Sell));
+        let out = fp.update(trade(100.1, 1.0, Side::Buy)).unwrap();
+        assert!(fp.is_ready());
+        // Bucket 100: buy 2 + buy 1 = ask 3, bid 0. Bucket 101: sell 3.
+        assert_eq!(out.levels.len(), 2);
+        assert_eq!(out.levels[0].price, 100.0);
+        assert_eq!(out.levels[0].ask_vol, 3.0);
+        assert_eq!(out.levels[0].bid_vol, 0.0);
+        assert_eq!(out.levels[1].price, 101.0);
+        assert_eq!(out.levels[1].bid_vol, 3.0);
+        assert_eq!(out.levels[1].ask_vol, 0.0);
+    }
+
+    #[test]
+    fn levels_sorted_ascending_by_price() {
+        let mut fp = Footprint::new(1.0).unwrap();
+        fp.update(trade(103.0, 1.0, Side::Buy));
+        fp.update(trade(100.0, 1.0, Side::Sell));
+        let out = fp.update(trade(101.0, 1.0, Side::Buy)).unwrap();
+        let prices: Vec<f64> = out.levels.iter().map(|l| l.price).collect();
+        assert_eq!(prices, vec![100.0, 101.0, 103.0]);
+    }
+
+    #[test]
+    fn sub_tick_prices_share_a_bucket() {
+        let mut fp = Footprint::new(0.5).unwrap();
+        // 100.24 and 100.26 both round to bucket 200 (price 100.0)... check:
+        // 100.24/0.5 = 200.48 -> 200; 100.26/0.5 = 200.52 -> 201. Distinct.
+        fp.update(trade(100.20, 1.0, Side::Buy)); // 200.4 -> 200 -> price 100.0
+        let out = fp.update(trade(100.10, 2.0, Side::Buy)).unwrap(); // 200.2 -> 200
+        assert_eq!(out.levels.len(), 1);
+        assert_eq!(out.levels[0].price, 100.0);
+        assert_eq!(out.levels[0].ask_vol, 3.0);
+    }
+
+    #[test]
+    fn reset_clears_the_footprint() {
+        let mut fp = Footprint::new(1.0).unwrap();
+        fp.update(trade(100.0, 5.0, Side::Buy));
+        assert!(fp.is_ready());
+        fp.reset();
+        assert!(!fp.is_ready());
+        let out = fp.update(trade(200.0, 1.0, Side::Sell)).unwrap();
+        assert_eq!(out.levels.len(), 1);
+        assert_eq!(out.levels[0].price, 200.0);
+        assert_eq!(out.levels[0].bid_vol, 1.0);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let trades: Vec<Trade> = (0..30)
+            .map(|i| {
+                let side = if i % 3 == 0 { Side::Sell } else { Side::Buy };
+                trade(100.0 + f64::from(i % 5), 1.0 + f64::from(i % 4), side)
+            })
+            .collect();
+        let mut a = Footprint::new(1.0).unwrap();
+        let mut b = Footprint::new(1.0).unwrap();
+        assert_eq!(
+            a.batch(&trades),
+            trades.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -0,0 +1,137 @@
+//! Funding Basis — the perpetual mark's relative premium to the spot index.
+
+use crate::derivatives::DerivativesTick;
+use crate::traits::Indicator;
+
+/// Funding Basis — the relative basis between the perpetual mark price and the
+/// spot index it tracks.
+///
+/// ```text
+/// basis = (markPrice − indexPrice) / indexPrice
+/// ```
+///
+/// The basis is the spread that the funding mechanism continuously pulls toward
+/// zero: a positive basis (perpetual above spot) goes hand in hand with positive
+/// funding (longs pay), a negative basis with negative funding. Reading the
+/// instantaneous basis alongside the [funding rate] separates a genuine premium
+/// from a stale-funding artefact and sizes the carry available to a cash-and-carry
+/// or basis-arbitrage trade. The output is a fraction (e.g. `0.001` = 10 bps);
+/// multiply by `10_000` for basis points.
+///
+/// `Input = DerivativesTick`, `Output = f64`. Stateless; ready after the first
+/// tick.
+///
+/// [funding rate]: crate::FundingRate
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, FundingBasis, Indicator};
+///
+/// let mut fb = FundingBasis::new();
+/// // mark 100.5 vs index 100.0 -> (100.5 - 100.0) / 100.0 = 0.005.
+/// let tick = DerivativesTick::new(
+///     0.0, 100.5, 100.0, 100.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
+/// )
+/// .unwrap();
+/// assert!((fb.update(tick).unwrap() - 0.005).abs() < 1e-12);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct FundingBasis {
+    has_emitted: bool,
+}
+
+impl FundingBasis {
+    /// Construct a new funding-basis indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for FundingBasis {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        self.has_emitted = true;
+        Some((tick.mark_price - tick.index_price) / tick.index_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 {
+        "FundingBasis"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn tick(mark: f64, index: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(0.0, mark, index, mark, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0)
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let fb = FundingBasis::new();
+        assert_eq!(fb.name(), "FundingBasis");
+        assert_eq!(fb.warmup_period(), 1);
+        assert!(!fb.is_ready());
+    }
+
+    #[test]
+    fn premium_is_positive() {
+        let mut fb = FundingBasis::new();
+        let out = fb.update(tick(100.5, 100.0)).unwrap();
+        assert!((out - 0.005).abs() < 1e-12);
+        assert!(fb.is_ready());
+    }
+
+    #[test]
+    fn discount_is_negative() {
+        let mut fb = FundingBasis::new();
+        let out = fb.update(tick(99.5, 100.0)).unwrap();
+        assert!((out + 0.005).abs() < 1e-12);
+    }
+
+    #[test]
+    fn at_par_is_zero() {
+        let mut fb = FundingBasis::new();
+        assert_eq!(fb.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) * 0.1, 100.0))
+            .collect();
+        let mut a = FundingBasis::new();
+        let mut b = FundingBasis::new();
+        assert_eq!(
+            a.batch(&ticks),
+            ticks.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut fb = FundingBasis::new();
+        fb.update(tick(100.5, 100.0));
+        assert!(fb.is_ready());
+        fb.reset();
+        assert!(!fb.is_ready());
+    }
+}

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

@@ -0,0 +1,131 @@
+//! Funding Rate — the current perpetual funding rate.
+
+use crate::derivatives::DerivativesTick;
+use crate::traits::Indicator;
+
+/// Funding Rate — the funding rate carried by each derivatives tick.
+///
+/// The funding rate is the periodic payment exchanged between long and short
+/// perpetual-swap holders that tethers the perpetual mark to the spot index. A
+/// positive rate means longs pay shorts (the perpetual trades at a premium); a
+/// negative rate means shorts pay longs (a discount). This indicator simply
+/// surfaces the rate from the [`DerivativesTick`] feed so it can be charted,
+/// chained or fed to the rolling funding statistics ([`FundingRateMean`],
+/// [`FundingRateZScore`]).
+///
+/// `Input = DerivativesTick`, `Output = f64`. Stateless; ready after the first
+/// tick.
+///
+/// [`FundingRateMean`]: crate::FundingRateMean
+/// [`FundingRateZScore`]: crate::FundingRateZScore
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, FundingRate, Indicator};
+///
+/// let mut fr = FundingRate::new();
+/// let tick = DerivativesTick::new(
+///     0.0001, 100.0, 100.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
+/// )
+/// .unwrap();
+/// assert_eq!(fr.update(tick), Some(0.0001));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct FundingRate {
+    has_emitted: bool,
+}
+
+impl FundingRate {
+    /// Construct a new funding-rate indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for FundingRate {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        self.has_emitted = true;
+        Some(tick.funding_rate)
+    }
+
+    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 {
+        "FundingRate"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn tick(funding_rate: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(
+            funding_rate,
+            100.0,
+            100.0,
+            100.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0,
+        )
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let fr = FundingRate::new();
+        assert_eq!(fr.name(), "FundingRate");
+        assert_eq!(fr.warmup_period(), 1);
+        assert!(!fr.is_ready());
+    }
+
+    #[test]
+    fn passes_through_funding_rate() {
+        let mut fr = FundingRate::new();
+        assert_eq!(fr.update(tick(0.0001)), Some(0.0001));
+        assert_eq!(fr.update(tick(-0.0003)), Some(-0.0003));
+        assert!(fr.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> =
+            (0..20).map(|i| tick(0.0001 * f64::from(i - 10))).collect();
+        let mut a = FundingRate::new();
+        let mut b = FundingRate::new();
+        assert_eq!(
+            a.batch(&ticks),
+            ticks.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut fr = FundingRate::new();
+        fr.update(tick(0.0001));
+        assert!(fr.is_ready());
+        fr.reset();
+        assert!(!fr.is_ready());
+    }
+}