feat(bindings): expose name() on every indicator in all 10 languages (#308)

* feat(bindings): expose name() on every indicator in Node, WASM, and Python

Surface the core Indicator::name() / BarBuilder::name() accessor through the
three native bindings so every indicator reports its canonical name at runtime,
matching the existing reset/isReady/warmupPeriod surface.

- Node (napi): name(): string on all 514 classes (regenerated index.d.ts)
- WASM (wasm-bindgen): name(): string on all 514 classes
- Python (pyo3): name() -> str on all classes

* feat(bindings): expose name() across the C ABI and C/C++/Go/C#/Java/R

Regenerate the C ABI and the four generated language bindings from the updated
ScriptHelpers generators so every indicator and bar builder reports its
canonical name at runtime, completing name() coverage across all 10 languages.

- C ABI (bindings/c): wickra_<ind>_name() -> *const c_char for all 514, cached
  in a per-function OnceLock<CString> with ind.name() as the source of truth;
  cbindgen header regenerated and vendored into bindings/go/include.
- Go: Name() string; C#: string Name(); Java: String name(); R: name() S3
  generic over the wk_<ind>_name C glue (methods.R + NAMESPACE).

The Java regeneration also restores two fixes that had drifted out of the
generator (bool* arrays via boolSegment; uint8_t ctor args cast to byte) and C#
re-emits '#nullable enable'; these are no-op vs the previous committed output
apart from the new name() accessors.

* test(golden): pin canonical name() across all 10 language bindings

Add a cross-language name() consistency check: every indicator must report the
exact core Indicator::name() (which can differ from the registered class name,
e.g. ChaikinMoneyFlow -> "CMF", Donchian -> "DonchianChannels"). The 514 core
names are committed as testdata/golden/names.json (keyed by Rust canonical) and
asserted by each binding's golden replay, which already reconstructs the whole
catalogue:

- node / wasm: assert against names.json in the existing golden test
- python: new test_golden_names.py over the shared node manifest
- go / csharp / java / c+c++ / r: the golden-test generators load names.json and
  emit a name assertion per indicator (regenerated test artifacts committed)

All 10 bindings return identical names by construction (each delegates to core),
so this pins that contract and guards against a future binding breaking the
passthrough.

* docs(changelog): record name() across all 10 bindings under Unreleased

* fix(r): restore bool* flag marshalling in the regenerated C glue

The name() regeneration had reverted the cross-section bool fix: the R glue
emitted (bool *)REAL(x) for const bool* inputs, reinterpreting 8-byte doubles as
1-byte bools so every flag read as false (PercentAboveMa, NewHighsNewLows,
HighLowIndex, BullishPercentIndex returned 0 instead of the breadth value). The
wk_bool_vec() helper is restored in the generator and the glue routes bool arrays
through it again.

bindings/java/src/main/java/org/wickra/AbandonedBaby.java

@@ -91,6 +91,16 @@ public final class AbandonedBaby implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ABANDONED_BABY_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Abcd.java

@@ -91,6 +91,16 @@ public final class Abcd implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ABCD_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AbsoluteBreadthIndex.java

@@ -77,6 +77,16 @@ public final class AbsoluteBreadthIndex implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AccelerationBands.java

@@ -67,6 +67,16 @@ public final class AccelerationBands implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ACCELERATION_BANDS_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AcceleratorOscillator.java

@@ -100,6 +100,16 @@ public final class AcceleratorOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdOscillator.java

@@ -91,6 +91,16 @@ public final class AdOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AD_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdVolumeLine.java

@@ -77,6 +77,16 @@ public final class AdVolumeLine implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AD_VOLUME_LINE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdaptiveCci.java

@@ -94,6 +94,16 @@ public final class AdaptiveCci implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_CCI_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdaptiveCycle.java

@@ -71,6 +71,16 @@ public final class AdaptiveCycle implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_CYCLE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdaptiveLaguerreFilter.java

@@ -74,6 +74,16 @@ public final class AdaptiveLaguerreFilter implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdaptiveRsi.java

@@ -74,6 +74,16 @@ public final class AdaptiveRsi implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_RSI_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Adl.java

@@ -91,6 +91,16 @@ public final class Adl implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADL_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdvanceBlock.java

@@ -91,6 +91,16 @@ public final class AdvanceBlock implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADVANCE_BLOCK_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdvanceDecline.java

@@ -77,6 +77,16 @@ public final class AdvanceDecline implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADVANCE_DECLINE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AdvanceDeclineRatio.java

@@ -77,6 +77,16 @@ public final class AdvanceDeclineRatio implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Adx.java

@@ -67,6 +67,16 @@ public final class Adx implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Adxr.java

@@ -94,6 +94,16 @@ public final class Adxr implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ADXR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Alligator.java

@@ -73,6 +73,16 @@ public final class Alligator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ALLIGATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Alma.java

@@ -74,6 +74,16 @@ public final class Alma implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ALMA_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Alpha.java

@@ -78,6 +78,16 @@ public final class Alpha implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ALPHA_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AmihudIlliquidity.java

@@ -59,6 +59,16 @@ public final class AmihudIlliquidity implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AnchoredRsi.java

@@ -71,6 +71,16 @@ public final class AnchoredRsi implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ANCHORED_RSI_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AnchoredVwap.java

@@ -91,6 +91,16 @@ public final class AnchoredVwap implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ANCHORED_VWAP_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AndrewsPitchfork.java

@@ -67,6 +67,16 @@ public final class AndrewsPitchfork implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ANDREWS_PITCHFORK_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Apo.java

@@ -77,6 +77,16 @@ public final class Apo implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_APO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Aroon.java

@@ -66,6 +66,16 @@ public final class Aroon implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AROON_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AroonOscillator.java

@@ -94,6 +94,16 @@ public final class AroonOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AROON_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Atr.java

@@ -94,6 +94,16 @@ public final class Atr implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ATR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AtrBands.java

@@ -67,6 +67,16 @@ public final class AtrBands implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ATR_BANDS_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AtrRatchet.java

@@ -66,6 +66,16 @@ public final class AtrRatchet implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ATR_RATCHET_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AtrTrailingStop.java

@@ -94,6 +94,16 @@ public final class AtrTrailingStop implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_ATR_TRAILING_STOP_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AutoFib.java

@@ -68,6 +68,16 @@ public final class AutoFib implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AUTO_FIB_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Autocorrelation.java

@@ -77,6 +77,16 @@ public final class Autocorrelation implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AUTOCORRELATION_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AutocorrelationPeriodogram.java

@@ -77,6 +77,16 @@ public final class AutocorrelationPeriodogram implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AverageDailyRange.java

@@ -94,6 +94,16 @@ public final class AverageDailyRange implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AverageDrawdown.java

@@ -74,6 +74,16 @@ public final class AverageDrawdown implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AvgPrice.java

@@ -91,6 +91,16 @@ public final class AvgPrice implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AVG_PRICE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AwesomeOscillator.java

@@ -97,6 +97,16 @@ public final class AwesomeOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/AwesomeOscillatorHistogram.java

@@ -13,19 +13,19 @@ public final class AwesomeOscillatorHistogram implements AutoCloseable {
     private final MemorySegment handle;
     private final Cleaner.Cleanable cleanable;
 
-    public AwesomeOscillatorHistogram(int fast, int slow, int smaPeriod) {
+    public AwesomeOscillatorHistogram(int fast, int slow, int lookback) {
         if (fast < 0) {
             throw new IllegalArgumentException("fast must be non-negative");
         }
         if (slow < 0) {
             throw new IllegalArgumentException("slow must be non-negative");
         }
-        if (smaPeriod < 0) {
-            throw new IllegalArgumentException("smaPeriod must be non-negative");
+        if (lookback < 0) {
+            throw new IllegalArgumentException("lookback must be non-negative");
         }
         MemorySegment h;
         try {
-            h = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NEW.invokeExact((long) fast, (long) slow, (long) smaPeriod);
+            h = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NEW.invokeExact((long) fast, (long) slow, (long) lookback);
         } catch (Throwable t) {
             throw WickraNative.rethrow(t);
         }
@@ -100,6 +100,16 @@ public final class AwesomeOscillatorHistogram implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BalanceOfPower.java

@@ -91,6 +91,16 @@ public final class BalanceOfPower implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BALANCE_OF_POWER_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BandpassFilter.java

@@ -74,6 +74,16 @@ public final class BandpassFilter implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BANDPASS_FILTER_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Bat.java

@@ -91,6 +91,16 @@ public final class Bat implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BAT_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BeltHold.java

@@ -91,6 +91,16 @@ public final class BeltHold implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BELT_HOLD_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Beta.java

@@ -78,6 +78,16 @@ public final class Beta implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BETA_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BetaNeutralSpread.java

@@ -78,6 +78,16 @@ public final class BetaNeutralSpread implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BetterVolume.java

@@ -94,6 +94,16 @@ public final class BetterVolume implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BETTER_VOLUME_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BipowerVariation.java

@@ -74,6 +74,16 @@ public final class BipowerVariation implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BIPOWER_VARIATION_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BodySizePct.java

@@ -91,6 +91,16 @@ public final class BodySizePct implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BODY_SIZE_PCT_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BollingerBands.java

@@ -68,6 +68,16 @@ public final class BollingerBands implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BOLLINGER_BANDS_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BollingerBandwidth.java

@@ -74,6 +74,16 @@ public final class BollingerBandwidth implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BomarBands.java

@@ -67,6 +67,16 @@ public final class BomarBands implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BOMAR_BANDS_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BreadthThrust.java

@@ -80,6 +80,16 @@ public final class BreadthThrust implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BREADTH_THRUST_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Breakaway.java

@@ -91,6 +91,16 @@ public final class Breakaway implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BREAKAWAY_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BullishPercentIndex.java

@@ -77,6 +77,16 @@ public final class BullishPercentIndex implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/BurkeRatio.java

@@ -74,6 +74,16 @@ public final class BurkeRatio implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BURKE_RATIO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Butterfly.java

@@ -91,6 +91,16 @@ public final class Butterfly implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_BUTTERFLY_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CalendarSpread.java

@@ -56,6 +56,16 @@ public final class CalendarSpread implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CALENDAR_SPREAD_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CalmarRatio.java

@@ -74,6 +74,16 @@ public final class CalmarRatio implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CALMAR_RATIO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Camarilla.java

@@ -70,6 +70,16 @@ public final class Camarilla implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CAMARILLA_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CandleVolume.java

@@ -66,6 +66,16 @@ public final class CandleVolume implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CANDLE_VOLUME_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Cci.java

@@ -94,6 +94,16 @@ public final class Cci implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CCI_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CenterOfGravity.java

@@ -74,6 +74,16 @@ public final class CenterOfGravity implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CENTER_OF_GRAVITY_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CentralPivotRange.java

@@ -64,6 +64,16 @@ public final class CentralPivotRange implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Cfo.java

@@ -74,6 +74,16 @@ public final class Cfo implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CFO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ChaikinMoneyFlow.java

@@ -94,6 +94,16 @@ public final class ChaikinMoneyFlow implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ChaikinOscillator.java

@@ -97,6 +97,16 @@ public final class ChaikinOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ChaikinVolatility.java

@@ -97,6 +97,16 @@ public final class ChaikinVolatility implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CHAIKIN_VOLATILITY_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ChandeKrollStop.java

@@ -69,6 +69,16 @@ public final class ChandeKrollStop implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CHANDE_KROLL_STOP_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ChandelierExit.java

@@ -66,6 +66,16 @@ public final class ChandelierExit implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CHANDELIER_EXIT_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ChoppinessIndex.java

@@ -94,6 +94,16 @@ public final class ChoppinessIndex implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CHOPPINESS_INDEX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ClassicPivots.java

@@ -68,6 +68,16 @@ public final class ClassicPivots implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CLASSIC_PIVOTS_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CloseVsOpen.java

@@ -91,6 +91,16 @@ public final class CloseVsOpen implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CLOSE_VS_OPEN_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ClosingMarubozu.java

@@ -91,6 +91,16 @@ public final class ClosingMarubozu implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CLOSING_MARUBOZU_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Cmo.java

@@ -74,6 +74,16 @@ public final class Cmo implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CMO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CoefficientOfVariation.java

@@ -74,6 +74,16 @@ public final class CoefficientOfVariation implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Cointegration.java

@@ -70,6 +70,16 @@ public final class Cointegration implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_COINTEGRATION_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CommonSenseRatio.java

@@ -74,6 +74,16 @@ public final class CommonSenseRatio implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_COMMON_SENSE_RATIO_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CompositeProfile.java

@@ -70,6 +70,16 @@ public final class CompositeProfile implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_COMPOSITE_PROFILE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ConcealingBabySwallow.java

@@ -91,6 +91,16 @@ public final class ConcealingBabySwallow implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ConditionalValueAtRisk.java

@@ -74,6 +74,16 @@ public final class ConditionalValueAtRisk implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CONDITIONAL_VALUE_AT_RISK_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/ConnorsRsi.java

@@ -80,6 +80,16 @@ public final class ConnorsRsi implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CONNORS_RSI_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Coppock.java

@@ -80,6 +80,16 @@ public final class Coppock implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_COPPOCK_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CorrelationTrendIndicator.java

@@ -74,6 +74,16 @@ public final class CorrelationTrendIndicator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CORRELATION_TREND_INDICATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Counterattack.java

@@ -91,6 +91,16 @@ public final class Counterattack implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_COUNTERATTACK_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Crab.java

@@ -91,6 +91,16 @@ public final class Crab implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CRAB_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CumulativeVolumeDelta.java

@@ -56,6 +56,16 @@ public final class CumulativeVolumeDelta implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CUMULATIVE_VOLUME_DELTA_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CumulativeVolumeIndex.java

@@ -77,6 +77,16 @@ public final class CumulativeVolumeIndex implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CUMULATIVE_VOLUME_INDEX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CupAndHandle.java

@@ -91,6 +91,16 @@ public final class CupAndHandle implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CUP_AND_HANDLE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/CyberneticCycle.java

@@ -74,6 +74,16 @@ public final class CyberneticCycle implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CYBERNETIC_CYCLE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Cypher.java

@@ -91,6 +91,16 @@ public final class Cypher implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_CYPHER_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DayOfWeekProfile.java

@@ -67,6 +67,16 @@ public final class DayOfWeekProfile implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DAY_OF_WEEK_PROFILE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Decycler.java

@@ -74,6 +74,16 @@ public final class Decycler implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DECYCLER_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DecyclerOscillator.java

@@ -77,6 +77,16 @@ public final class DecyclerOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DECYCLER_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/Dema.java

@@ -74,6 +74,16 @@ public final class Dema implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DEMA_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DemandIndex.java

@@ -94,6 +94,16 @@ public final class DemandIndex implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DEMAND_INDEX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DemarkPivots.java

@@ -64,6 +64,16 @@ public final class DemarkPivots implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DEMARK_PIVOTS_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DepthSlope.java

@@ -66,6 +66,16 @@ public final class DepthSlope implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DEPTH_SLOPE_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DerivativeOscillator.java

@@ -83,6 +83,16 @@ public final class DerivativeOscillator implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DERIVATIVE_OSCILLATOR_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DetrendedStdDev.java

@@ -74,6 +74,16 @@ public final class DetrendedStdDev implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DETRENDED_STD_DEV_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {

bindings/java/src/main/java/org/wickra/DisparityIndex.java

@@ -74,6 +74,16 @@ public final class DisparityIndex implements AutoCloseable {
         }
     }
 
+    /** The indicator's canonical name. */
+    public String name() {
+        try {
+            MemorySegment s = (MemorySegment) NativeMethods.WICKRA_DISPARITY_INDEX_NAME.invokeExact(handle);
+            return s.address() == 0 ? "" : s.reinterpret(Long.MAX_VALUE).getString(0);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
     /** Reset to the just-constructed state. */
     public void reset() {
         try {