@adaptic/utils 0.0.1031 → 0.0.1032

package/dist/types/__tests__/indicator-parity/generate.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Builds the prefix-parity golden master by running BOTH the production
+ * indicators and the independent references over every (series, prefix) pair.
+ *
+ * The fixture is never generated from production alone. Each point carries the
+ * reference outcome beside the production outcome and a `deviates` flag, so a
+ * disagreement is recorded as a disagreement rather than silently becoming the
+ * expected answer — which is the failure mode a golden master most easily
+ * introduces.
+ *
+ * Generation and verification share this module, so the record can never be
+ * produced by a different code path from the one that checks it.
+ */
+import { type Outcome, type ParityFixture, type ParityTrack } from "./record";
+import { type ParityBar, type ParitySeriesId } from "./series";
+import { type ParitySubject } from "./subjects";
+/**
+ * Run one implementation and capture what it did, value or throw alike.
+ *
+ * A thrown error is a first-class recorded outcome. "This input must raise" is
+ * a contract, and an implementation that quietly begins returning a number for
+ * a malformed request has changed that contract just as surely as one that
+ * changes a value.
+ *
+ * @param invoke - The implementation to run.
+ * @param bars - The prefix to run it over.
+ * @returns The outcome, as stored in the fixture.
+ */
+export declare function captureOutcome(invoke: (bars: readonly ParityBar[]) => ReturnType<ParitySubject["production"]>, bars: readonly ParityBar[]): Outcome;
+/**
+ * Record one subject against one series, at every prefix length.
+ *
+ * @param subject - The indicator configuration.
+ * @param seriesId - The adversarial series.
+ * @returns The recorded track.
+ */
+export declare function buildTrack(subject: ParitySubject, seriesId: ParitySeriesId): ParityTrack;
+/**
+ * Build the whole golden master from the current tree.
+ *
+ * @returns The fixture, ready to serialise or to compare against the stored one.
+ */
+export declare function buildFixture(): ParityFixture;
+/**
+ * Where the golden master lives, relative to the package root.
+ *
+ * Declared once so the generator and the test cannot drift onto two different
+ * files — a check that reads a fixture nobody writes passes forever.
+ */
+export declare const FIXTURE_PATH_FROM_PACKAGE_ROOT = "src/__tests__/fixtures/indicator-prefix-parity.json";
+/**
+ * Serialise the fixture the way it is stored on disk.
+ *
+ * One recorded point per line, hand-assembled rather than handed to
+ * `JSON.stringify(..., 2)`. Fully indented output runs to tens of thousands of
+ * lines for the same data, which makes a diff unreadable and a review
+ * impossible — and an unreviewable golden master is a golden master nobody
+ * checks. The output is still ordinary JSON.
+ *
+ * @param fixture - The fixture to serialise.
+ * @returns JSON with one point per line and a trailing newline.
+ */
+export declare function serialiseFixture(fixture: ParityFixture): string;
+//# sourceMappingURL=generate.d.ts.map

package/dist/types/__tests__/indicator-parity/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/indicator-parity/generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAIL,KAAK,OAAO,EACZ,KAAK,aAAa,EAElB,KAAK,WAAW,EACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,KAAK,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,EAC/E,IAAI,EAAE,SAAS,SAAS,EAAE,GACzB,OAAO,CAST;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,cAAc,GACvB,WAAW,CAYb;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,aAAa,CAY5C;AAED;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,wDACY,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAuB/D"}

package/dist/types/__tests__/indicator-parity/record.d.ts

@@ -0,0 +1,144 @@
+/**
+ * The golden-master record shape, its JSON codec, and the inventory of places
+ * where production is KNOWN to disagree with the independent reference.
+ *
+ * The deviation inventory is the mechanism that keeps this fixture honest. A
+ * golden master recorded from current output silently promotes every live
+ * defect to a specification; recording production AND an independent reference,
+ * and requiring every disagreement between them to be declared here with its
+ * mechanism, means a new disagreement fails the suite instead of being
+ * absorbed. Removing an entry from this list is how a fix gets proven.
+ */
+import type { ParitySeriesId } from "./series";
+/**
+ * A number as stored in JSON. `NaN` and the infinities have no JSON literal, so
+ * they are tagged strings; every other value is the double itself, which
+ * `JSON.stringify` round-trips exactly.
+ */
+export type EncodedNumber = number | "NaN" | "Infinity" | "-Infinity";
+/** Encode a number for storage. */
+export declare function encodeNumber(value: number): EncodedNumber;
+/** Decode a stored number. */
+export declare function decodeNumber(value: EncodedNumber): number;
+/**
+ * One emitted indicator reading: which bar it describes, and each component it
+ * carries. `null` marks a component the indicator did not produce for that bar.
+ */
+export interface IndicatorEntry {
+    readonly barIndex: number;
+    readonly components: Readonly<Record<string, number | null>>;
+}
+/**
+ * What an indicator did when fed one prefix.
+ *
+ * `count` and `firstBarIndex` pin the SHAPE of the warm-up — how many values
+ * came out and which bar the first one describes — which is precisely what a
+ * restart-shaped history corrupts. `tail` pins the newest value, the one a live
+ * consumer reads. Recording the tail at every prefix length from the shortest
+ * upward covers every value the indicator ever emits, with no redundancy.
+ */
+export interface Reading {
+    readonly count: number;
+    readonly firstBarIndex: number | null;
+    readonly tailBarIndex: number | null;
+    readonly tail: Readonly<Record<string, EncodedNumber | null>> | null;
+}
+/**
+ * The outcome of one invocation. A throw is recorded as tightly as a value:
+ * "this input must raise" is part of the contract, and an implementation that
+ * quietly starts returning a number instead has changed its contract.
+ */
+export type Outcome = {
+    readonly kind: "reading";
+    readonly reading: Reading;
+} | {
+    readonly kind: "throws";
+    readonly message: string;
+};
+/**
+ * Production and reference outcomes for one (subject, series, prefix).
+ *
+ * `reference` is stored ONLY when it differs from `production`. Agreement is
+ * the common case and storing it twice would bury the disagreements — which
+ * are the rows a reviewer needs to see — under thousands of identical lines.
+ * An absent `reference` means "identical to production", and `deviates` states
+ * which case this is so the file can be read without inferring it.
+ */
+export interface ParityPoint {
+    readonly prefix: number;
+    readonly production: Outcome;
+    /** Present only when it differs from `production`; every such row must be declared below. */
+    readonly reference?: Outcome;
+    /** True exactly when `reference` is present. */
+    readonly deviates: boolean;
+}
+/**
+ * The reference outcome for a point, reconstructing the agreement case.
+ *
+ * @param point - The recorded point.
+ * @returns What the independent reference produced.
+ */
+export declare function referenceOf(point: ParityPoint): Outcome;
+/** Every recorded point for one subject on one series. */
+export interface ParityTrack {
+    readonly subjectId: string;
+    readonly seriesId: ParitySeriesId;
+    readonly points: readonly ParityPoint[];
+}
+/** The whole golden master. */
+export interface ParityFixture {
+    /** Bumped when the record SHAPE changes, so a stale fixture fails loudly. */
+    readonly formatVersion: number;
+    readonly seriesLength: number;
+    readonly tracks: readonly ParityTrack[];
+}
+/** Current record shape. */
+export declare const FIXTURE_FORMAT_VERSION = 1;
+/**
+ * A known, mechanism-explained disagreement between production and the
+ * reference. Each entry is a live defect this harness has pinned rather than
+ * hidden.
+ */
+export interface DeclaredDeviation {
+    readonly subjectId: string;
+    readonly seriesIds: readonly ParitySeriesId[];
+    /** Stable id, quotable in a report or a follow-up item. */
+    readonly finding: string;
+    /** What the implementation does differently, and why that is wrong. */
+    readonly mechanism: string;
+}
+/**
+ * Every disagreement this repository knows about, with its mechanism.
+ *
+ * An undeclared disagreement fails the suite. A declared one that stops
+ * occurring also fails it, so a fix cannot land without deleting its entry —
+ * the list cannot rot in either direction.
+ */
+export declare const DECLARED_DEVIATIONS: readonly DeclaredDeviation[];
+/**
+ * Whether a disagreement on this (subject, series) pair has been declared.
+ *
+ * @param subjectId - The indicator configuration under test.
+ * @param seriesId - The adversarial series.
+ * @returns The declaration, or `undefined` when the pair is undeclared.
+ */
+export declare function declaredDeviationFor(subjectId: string, seriesId: ParitySeriesId): DeclaredDeviation | undefined;
+/**
+ * Reduce a list of emitted entries to the recorded {@link Reading}.
+ *
+ * @param entries - Everything the indicator emitted for this prefix.
+ * @returns The shape-plus-tail summary stored in the fixture.
+ */
+export declare function toReading(entries: readonly IndicatorEntry[]): Reading;
+/**
+ * Whether two outcomes are identical, comparing `NaN` as equal to itself.
+ *
+ * `NaN !== NaN` would make every corrupted-series record permanently unequal to
+ * itself, which would turn the most important rows in this fixture into noise.
+ *
+ * @param a - First outcome.
+ * @param b - Second outcome.
+ * @returns Whether they describe the same result.
+ */
+export declare function outcomesEqual(a: Outcome, b: Outcome): boolean;
+//# sourceMappingURL=record.d.ts.map

package/dist/types/__tests__/indicator-parity/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/indicator-parity/record.ts"],"names":[],"mappings":"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"}

package/dist/types/__tests__/indicator-parity/reference.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Independent reference implementations of the recursive indicators.
+ *
+ * These are written from each indicator's DEFINITION, not from the production
+ * code, and exist so the golden master is anchored to something outside the
+ * implementation it is meant to protect. A fixture generated from current
+ * output pins today's defects as the specification; a fixture checked against
+ * an independent derivation turns a defect into a visible, enumerated
+ * disagreement instead.
+ *
+ * Every function here applies the recurrence to the numbers it is given and
+ * nothing else. In particular it does NOT special-case non-finite input: if a
+ * bar is `NaN`, the recurrence carries `NaN` forward, because that is what the
+ * arithmetic says. Where production returns a plausible number from the same
+ * input, the disagreement is the finding.
+ *
+ * Each series is returned indexed by BAR, with `null` before the warm-up ends,
+ * so a value can always be traced to the bar that produced it.
+ */
+/**
+ * Exponential moving average, seeded with the simple mean of the first
+ * `period` values and smoothed thereafter by `2 / (period + 1)`.
+ *
+ * @param values - The input series.
+ * @param period - Lookback; must be a positive integer.
+ * @returns One entry per input index; `null` before index `period - 1`.
+ */
+export declare function referenceEma(values: readonly number[], period: number): (number | null)[];
+/** One MACD reading, tied to the bar that produced it. */
+export interface ReferenceMacdEntry {
+    /** Index of the bar this reading describes. */
+    readonly barIndex: number;
+    /** Fast EMA minus slow EMA. */
+    readonly macd: number;
+    /** EMA of the MACD line over `signalPeriod`. */
+    readonly signal: number;
+    /** `macd - signal`. */
+    readonly histogram: number;
+}
+/**
+ * MACD from two EMAs of the closes plus an EMA of their difference.
+ *
+ * The signal line is seeded with the simple mean of the first `signalPeriod`
+ * MACD values, which is the same seeding rule the two price EMAs use — the
+ * definition is one rule applied three times, not three rules.
+ *
+ * @param closes - Close series.
+ * @param shortPeriod - Fast EMA lookback.
+ * @param longPeriod - Slow EMA lookback.
+ * @param signalPeriod - Signal EMA lookback.
+ * @returns One entry per bar that has a signal value; empty when the series is too short.
+ */
+export declare function referenceMacd(closes: readonly number[], shortPeriod: number, longPeriod: number, signalPeriod: number): ReferenceMacdEntry[];
+/**
+ * Wilder's Relative Strength Index.
+ *
+ * The totality rule — a window with no losses scores 100, a window with neither
+ * gains nor losses scores the neutral 50 — is taken from the production
+ * module's own stated contract rather than invented here, since the textbook
+ * formula leaves `0 / 0` undefined. That makes agreement on the FLAT series
+ * weaker evidence than agreement on the drifting ones: it confirms the
+ * documented rule is implemented, not that the rule is the only correct one.
+ *
+ * Non-finite changes are carried forward as non-finite. A bar the feed
+ * corrupted is not a bar with zero change.
+ *
+ * @param closes - Close series.
+ * @param period - Wilder lookback.
+ * @returns One entry per bar; `null` before index `period`.
+ */
+export declare function referenceRsi(closes: readonly number[], period: number): (number | null)[];
+/**
+ * Wilder's Average True Range, seeded with the simple mean of the first
+ * `period` true ranges and smoothed by `(prior * (period - 1) + tr) / period`.
+ *
+ * @param highs - High series.
+ * @param lows - Low series.
+ * @param closes - Close series.
+ * @param period - Wilder lookback.
+ * @returns One entry per bar; `null` before index `period` (the first bar has no prior close).
+ */
+export declare function referenceAtr(highs: readonly number[], lows: readonly number[], closes: readonly number[], period: number): (number | null)[];
+/**
+ * RiskMetrics-style EWMA volatility: the square root of a variance seeded with
+ * the first squared return and decayed by `lambda` thereafter.
+ *
+ * @param returns - Period returns.
+ * @param lambda - Decay factor in (0, 1).
+ * @returns The EWMA standard deviation, or `null` on empty input.
+ */
+export declare function referenceEwmaVolatility(returns: readonly number[], lambda: number): number | null;
+//# sourceMappingURL=reference.d.ts.map

package/dist/types/__tests__/indicator-parity/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/indicator-parity/reference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAWnB;AAED,0DAA0D;AAC1D,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uBAAuB;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACnB,kBAAkB,EAAE,CA8BtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAsCnB;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAanB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAOf"}

package/dist/types/__tests__/indicator-parity/series.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The adversarial bar series the prefix-parity golden master is recorded over.
+ *
+ * Every value here is produced by integer arithmetic scaled by an exact power
+ * of two, so each close is exactly representable as a double and the series is
+ * byte-identical on every platform and every engine version. A fixture whose
+ * inputs drift is not a golden master; it is a slow-moving flake.
+ *
+ * The four shapes are chosen for what they do to a RECURSION, not for realism:
+ * a constant series drives every difference-based indicator onto its `0 / 0`
+ * branch, a jump series makes the warm-up window decide the answer, and the
+ * non-finite series ask whether a corrupted bar propagates loudly or is
+ * silently absorbed into a plausible number.
+ */
+import type { MassivePriceData } from "../../types/massive-types";
+/**
+ * One bar of the synthetic series.
+ *
+ * This is the production bar type, not a local stand-in: an indicator that
+ * silently started reading a field the harness does not populate would be
+ * caught by the compiler here rather than by a wrong number in a fixture. The
+ * `date` carries the bar's index (`d<index>`) so an emitted value can be traced
+ * back to the bar that produced it.
+ */
+export type ParityBar = MassivePriceData;
+/** Identifier of one adversarial series. */
+export type ParitySeriesId = "flat" | "gaps" | "nan" | "inf";
+/** Bars in the longest series recorded. Prefixes are taken from its front. */
+export declare const SERIES_LENGTH = 60;
+/** Shortest prefix recorded. Below this no indicator under test emits anything. */
+export declare const MIN_PREFIX = 5;
+/**
+ * Build the full bar series for one adversarial shape.
+ *
+ * High and low are derived from the close by exact eighths, so a corrupted
+ * close corrupts the whole bar — which is what a corrupted feed actually does,
+ * and what makes the true-range recursions see the same defect the close-based
+ * ones see.
+ *
+ * @param id - Which series to build.
+ * @returns `SERIES_LENGTH` bars.
+ */
+export declare function buildSeries(id: ParitySeriesId): ParityBar[];
+/** Every adversarial series, in recording order. */
+export declare const PARITY_SERIES_IDS: readonly ParitySeriesId[];
+/**
+ * Every prefix length recorded, shortest first.
+ *
+ * @returns Lengths from {@link MIN_PREFIX} through {@link SERIES_LENGTH}.
+ */
+export declare function prefixLengths(): number[];
+/**
+ * Simple period returns from a close series, used by the volatility recursion.
+ *
+ * A zero prior close would make the return undefined; none of these series
+ * contains one, and the guard states that rather than silently substituting a
+ * value if a future series ever does.
+ *
+ * @param closes - The close series.
+ * @returns `closes.length - 1` returns.
+ * @throws When a prior close is exactly zero.
+ */
+export declare function simpleReturns(closes: readonly number[]): number[];
+//# sourceMappingURL=series.d.ts.map

package/dist/types/__tests__/indicator-parity/series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"series.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/indicator-parity/series.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC;AAEzC,4CAA4C;AAC5C,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;AAE7D,8EAA8E;AAC9E,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,mFAAmF;AACnF,eAAO,MAAM,UAAU,IAAI,CAAC;AA6F5B;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,SAAS,EAAE,CAyB3D;AAED,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAKtD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAIxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAUjE"}

package/dist/types/__tests__/indicator-parity/subjects.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The inventory of recursive indicators under prefix-parity protection.
+ *
+ * "Recursive" here means the value at bar N is computed from the indicator's
+ * own value at bar N-1. That property is what makes these functions sensitive
+ * to how much history they are handed: a restart that refills a short buffer
+ * seeds the recursion somewhere else, and the value that comes out is a
+ * different number with the same name. Window statistics (Bollinger,
+ * Stochastic, realized volatility) recompute from scratch over a fixed slice
+ * and are deliberately out of scope.
+ *
+ * Each subject exposes the production call and the independent reference call
+ * in one shape — bar index plus named components — so the two can be compared
+ * row for row.
+ *
+ * The output QUANTISER is shared with production on purpose. `roundToPriceScale`
+ * and the RSI's two-decimal rounding are presentation decisions the production
+ * module states explicitly; reproducing them in the reference keeps the
+ * comparison about the recursion rather than about display precision, which is
+ * the part a warm-up defect actually corrupts.
+ */
+import type { IndicatorEntry } from "./record";
+import { type ParityBar } from "./series";
+/** One indicator configuration, with both implementations of it. */
+export interface ParitySubject {
+    /** Stable id used by the fixture and the deviation inventory. */
+    readonly id: string;
+    /** What this configuration is and why it is recorded. */
+    readonly description: string;
+    /**
+     * Whether the call emits one entry per bar (true) or only the newest value
+     * (false).
+     *
+     * Only a bar-indexed series can be checked for prefix parity positionally: a
+     * scalar call attributes its single reading to whatever the last bar of the
+     * prefix happens to be, so its entry list shifts with the prefix by design.
+     * Scalar subjects are checked instead against the series primitive they
+     * delegate to.
+     */
+    readonly emitsSeries: boolean;
+    /** The production call. May throw; a throw is part of the record. */
+    readonly production: (bars: readonly ParityBar[]) => IndicatorEntry[];
+    /** The independent reference call. May throw. */
+    readonly reference: (bars: readonly ParityBar[]) => IndicatorEntry[];
+}
+/**
+ * Every recursive indicator configuration recorded by the golden master.
+ *
+ * Both a defect-free configuration and the defaults consumers actually use are
+ * recorded for the EMA and MACD families, because the warm-up defect only
+ * appears when one period is shorter than the other — recording only the clean
+ * configuration would leave the live one unprotected.
+ */
+export declare const PARITY_SUBJECTS: readonly ParitySubject[];
+//# sourceMappingURL=subjects.d.ts.map

package/dist/types/__tests__/indicator-parity/subjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subjects.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/indicator-parity/subjects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAiBH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAiDzD,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,KAAK,cAAc,EAAE,CAAC;IACtE,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,KAAK,cAAc,EAAE,CAAC;CACtE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EA6NnD,CAAC"}

package/dist/types/__tests__/support/statistic.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Test-side accessors for {@link SampleStatistic} results.
+ *
+ * The union deliberately has no way to read a value without first proving the
+ * statistic exists. These helpers keep that proof in one place so assertions
+ * stay about the arithmetic, and so a test that expected a measurement and got
+ * an absence fails on that fact rather than on a downstream `undefined`.
+ */
+import type { SampleStatistic } from "../../sample-statistic";
+/**
+ * The measured value, or a failure naming why there was none.
+ *
+ * @param statistic - The result under test.
+ * @returns The measured value.
+ * @throws When the statistic is the unavailable branch.
+ */
+export declare function measured<T>(statistic: SampleStatistic<T>): T;
+//# sourceMappingURL=statistic.d.ts.map

package/dist/types/__tests__/support/statistic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistic.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/support/statistic.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAO5D"}

package/dist/types/index.d.ts

@@ -43,6 +43,7 @@ export declare const createAlpacaMarketDataAPI: () => AlpacaMarketDataAPI;
 export * from "./alpaca";
 export { createBrokerClient, type BrokerClientConfig, type BrokerTradingClient, type BrokerValidatedCredentials, } from "./broker";
 export * as tradingPolicy from "./trading-policy";
+export { availableStatistic, isAvailable, sampleCohort, unavailableStatistic, type AvailableStatistic, type SampleCohort, type SampleStatistic, type StatisticUnavailableReason, type UnavailableStatistic, } from "./sample-statistic";
 export * as atr from "./atr";
 export * as volatility from "./volatility";
 export * as risk from "./risk-metrics";

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/types/metrics-calcs.d.ts

@@ -1,6 +1,31 @@
 import { Bar, BenchmarkBar } from "./types/alpaca-types";
 import { types } from "@adaptic/backend";
 import { CalculateBetaResult, TradeMetrics } from "./types";
+/**
+ * Beta of a portfolio against a benchmark, from paired period returns.
+ *
+ * Non-finite rows are dropped pairwise — a return that is `NaN` on either leg
+ * cannot contribute to a covariance — and the count that survives is reported
+ * as the cohort rather than discarded. That reporting is the point: silently
+ * computing a beta on the 12 rows that happened to be clean, and returning it
+ * with the same shape as a beta over all 900, is how a statistic measured on
+ * one population gets applied to another.
+ *
+ * When beta cannot be computed the result is the unavailable branch, never a
+ * numeric stand-in. A beta of `0` asserts that the portfolio does not move with
+ * the market, which is a strong and consequential claim; emitting it to mean
+ * "we could not tell" makes every alpha derived from it wrong by the whole
+ * benchmark term.
+ *
+ * @param portfolioReturns - Portfolio period returns.
+ * @param benchmarkReturns - Benchmark period returns, index-aligned to the portfolio.
+ * @returns The beta components with their cohort, or a typed unavailable result.
+ * @example
+ * const result = calculateBetaFromReturns([0.05, -0.02, 0.03], [0.03, -0.01, 0.02]);
+ * if (result.available) {
+ *   // result.value.beta, alongside result.sampleCount and result.coverage
+ * }
+ */
 export declare function calculateBetaFromReturns(portfolioReturns: number[], benchmarkReturns: number[]): CalculateBetaResult;
 /**
  * Calculate max drawdown taking position type into account

package/dist/types/metrics-calcs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metrics-calcs.d.ts","sourceRoot":"","sources":["../../src/metrics-calcs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAsJ5D,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,EAAE,EAC1B,gBAAgB,EAAE,MAAM,EAAE,GACzB,mBAAmB,CA4FrB;AAgQD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,GAAG,EAAE,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,CAmCjB;AA8CD,wBAA8B,iBAAiB,CAC7C,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,SAAS,EAAE,GAAG,EAAE,EAChB,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC,YAAY,CAAC,CA0DvB"}
+{"version":3,"file":"metrics-calcs.d.ts","sourceRoot":"","sources":["../../src/metrics-calcs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AA0I5D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,EAAE,EAC1B,gBAAgB,EAAE,MAAM,EAAE,GACzB,mBAAmB,CA6FrB;AA6QD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,GAAG,EAAE,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,CAmCjB;AA8CD,wBAA8B,iBAAiB,CAC7C,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,SAAS,EAAE,GAAG,EAAE,EAChB,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC,YAAY,CAAC,CA0DvB"}

package/dist/types/performance-metrics.d.ts

@@ -78,10 +78,22 @@ export declare function alignReturnsByDate(portfolioHistory: PortfolioHistory, b
     alignedBenchmarkReturns: number[];
 };
 /**
- * Calculates the beta of the portfolio compared to a benchmark.
- * @param portfolioReturns - Array of portfolio returns.
- * @param benchmarkReturns - Array of benchmark returns.
- * @returns An object containing beta and intermediate calculations.
+ * Beta of a portfolio against a benchmark, from paired period returns.
+ *
+ * The two series are index-aligned pairs by contract: every mean, covariance
+ * and variance below is taken over the SAME row set. A length mismatch is
+ * therefore reported as invalid input rather than absorbed, because dividing
+ * one series' sum by the other series' length produces a mean of a population
+ * that does not exist — a number with no cohort, which is the failure this
+ * return type exists to make impossible.
+ *
+ * An uncomputable beta is returned as the unavailable branch, never as `0`.
+ * Zero beta is a claim of no market exposure, and downstream alpha attributes
+ * the entire benchmark move to the strategy when it believes that claim.
+ *
+ * @param portfolioReturns - Portfolio period returns.
+ * @param benchmarkReturns - Benchmark period returns, index-aligned to the portfolio.
+ * @returns The beta components with their cohort, or a typed unavailable result.
  */
 export declare function calculateBetaFromReturns(portfolioReturns: number[], benchmarkReturns: number[]): CalculateBetaResult;
 /**

package/dist/types/performance-metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"performance-metrics.d.ts","sourceRoot":"","sources":["../../src/performance-metrics.ts"],"names":[],"mappings":"AASA,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,mBAAmB,EAEnB,uBAAuB,EACvB,UAAU,EAEX,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC7B,MAAM,uBAAuB,CAAC;AAgD/B;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,SAAS,EACT,MAAM,EACN,aAAa,GACd,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiF3C;AAwBD;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,MAAM,CAAC,CA2CjB;AAqMD;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE,wBAAwB,EAC1C,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAiOD;AAkCD,UAAU,cAAc;IACtB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;CACrB,GACL,cAAc,CAuHhB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EAAE,EAChB,QAAQ,GAAE,MAAU,GACnB,MAAM,CAGR;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAchE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,gBAAgB,EAClC,aAAa,EAAE,YAAY,EAAE,GAC5B;IAAE,uBAAuB,EAAE,MAAM,EAAE,CAAC;IAAC,uBAAuB,EAAE,MAAM,EAAE,CAAA;CAAE,CAiF1E;AAkFD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,EAAE,EAC1B,gBAAgB,EAAE,MAAM,EAAE,GACzB,mBAAmB,CAoErB;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,gBAAgB,EAAE,wBAAwB,EAC1C,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,CAmHjB;AA+BD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,sBAAsB,CAAC,WAAW,CAAC,CAAC;CAChD,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAsB1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,MAAM,EACN,MAAM,EACN,SAAS,EACT,aAAa,GACd,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0J5D"}
+{"version":3,"file":"performance-metrics.d.ts","sourceRoot":"","sources":["../../src/performance-metrics.ts"],"names":[],"mappings":"AASA,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,mBAAmB,EAEnB,uBAAuB,EACvB,UAAU,EAEX,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC7B,MAAM,uBAAuB,CAAC;AAqD/B;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,SAAS,EACT,MAAM,EACN,aAAa,GACd,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiF3C;AAwBD;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,MAAM,CAAC,CA2CjB;AAqMD;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE,wBAAwB,EAC1C,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CA+OD;AAkCD,UAAU,cAAc;IACtB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;CACrB,GACL,cAAc,CAuHhB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EAAE,EAChB,QAAQ,GAAE,MAAU,GACnB,MAAM,CAGR;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAchE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,gBAAgB,EAClC,aAAa,EAAE,YAAY,EAAE,GAC5B;IAAE,uBAAuB,EAAE,MAAM,EAAE,CAAC;IAAC,uBAAuB,EAAE,MAAM,EAAE,CAAA;CAAE,CAiF1E;AAkFD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,EAAE,EAC1B,gBAAgB,EAAE,MAAM,EAAE,GACzB,mBAAmB,CA2ErB;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,gBAAgB,EAAE,wBAAwB,EAC1C,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,CAmHjB;AA+BD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,sBAAsB,CAAC,WAAW,CAAC,CAAC;CAChD,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAsB1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,MAAM,EACN,MAAM,EACN,SAAS,EACT,aAAa,GACd,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0J5D"}