investing 0.1.310 → 0.1.311

package/dist/prediction/analysis/polymarket-wallet-trust.d.ts

@@ -1,60 +0,0 @@
-import { ExcludedPosition, RMultipleExclusionReason } from './r-multiple';
-import { SettledPosition } from './position-settlement';
-import { ReconstructionSkip } from './position-reconstruction';
-import { ForecasterTrustScore, ForecasterTrustScoreOptions } from './trust-score';
-/** The database-shaped fields required by the pure wallet-history adapter. */
-export interface StoredWalletTradeRow {
-    id: string;
-    traderId: string;
-    conditionId: string;
-    type: string;
-    side: string | null;
-    outcomeIndex: number | null;
-    size: number;
-    usdcSize: number;
-    /** Drizzle `integer(..., { mode: "timestamp" })` returns a Date. */
-    timestamp: Date;
-}
-export interface PolymarketWalletTrustOptions extends ForecasterTrustScoreOptions {
-    /** Passed to the existing R-multiple converter. Defaults to zero. */
-    minInitialRisk?: number;
-}
-export interface PolymarketWalletTrustInputs {
-    wallet: {
-        kind: "polymarket-proxy-wallet";
-        id: string;
-    };
-    /** Inclusive historical cutoff, in epoch seconds. */
-    cutoff: number;
-    /** Explicitly prevents this partial record from being presented as complete. */
-    coverage: {
-        basis: "sell-closed-only";
-        historyCompleteness: "unknown";
-        resolutionEvidence: "none";
-    };
-    /** SELL-closed and unresolved residual episodes produced by settlement. */
-    positions: SettledPosition[];
-    /** Rows/groups rejected by conservative reconstruction validation. */
-    reconstructionSkips: ReconstructionSkip[];
-    /** Finite R-multiples from SELL-closed positions only. */
-    rMultiples: number[];
-    includedPositions: number;
-    rMultipleExclusions: ExcludedPosition[];
-    rMultipleExclusionCounts: Record<RMultipleExclusionReason, number>;
-    trust: ForecasterTrustScore;
-}
-/**
- * Purely converts stored wallet rows into R-multiples and a TRUST result.
- *
- * Raw rows are cutoff-filtered before settlement. A valid future row therefore
- * cannot close, oversell, or poison an episode as it existed at the cutoff.
- * Invalid numeric fields are passed through unchanged and are conservatively
- * reported by settlement; this adapter never coerces them to zero.
- */
-export declare function buildPolymarketWalletTrustInputs(walletId: string, cutoff: number, rows: readonly StoredWalletTradeRow[], options?: PolymarketWalletTrustOptions): PolymarketWalletTrustInputs;
-/**
- * Loads all locally stored TRADE rows for a wallet through `cutoff`, then runs
- * the pure SELL-closed-only adapter. Local-table completeness remains unknown.
- */
-export declare function loadPolymarketWalletTrustInputs(walletId: string, cutoff: number, options?: PolymarketWalletTrustOptions): Promise<PolymarketWalletTrustInputs>;
-//# sourceMappingURL=polymarket-wallet-trust.d.ts.map

package/dist/prediction/analysis/polymarket-wallet-trust.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polymarket-wallet-trust.d.ts","sourceRoot":"","sources":["../../../src/prediction/analysis/polymarket-wallet-trust.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAC;AACtB,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAEvB,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,4BACf,SAAQ,2BAA2B;IACnC,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE;QACN,IAAI,EAAE,yBAAyB,CAAC;QAChC,EAAE,EAAE,MAAM,CAAC;KACZ,CAAC;IACF,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,QAAQ,EAAE;QACR,KAAK,EAAE,kBAAkB,CAAC;QAC1B,mBAAmB,EAAE,SAAS,CAAC;QAC/B,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,2EAA2E;IAC3E,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,sEAAsE;IACtE,mBAAmB,EAAE,kBAAkB,EAAE,CAAC;IAC1C,0DAA0D;IAC1D,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,gBAAgB,EAAE,CAAC;IACxC,wBAAwB,EAAE,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC;IACnE,KAAK,EAAE,oBAAoB,CAAC;CAC7B;AASD;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,oBAAoB,EAAE,EACrC,OAAO,GAAE,4BAAiC,GACzC,2BAA2B,CA8D7B;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,2BAA2B,CAAC,CAQtC"}

package/dist/prediction/analysis/position-reconstruction.d.ts

@@ -1,130 +0,0 @@
-import { ResolvedPosition } from './r-multiple';
-/**
- * The subset of a `polymarket_trade_history` row this reconstruction needs.
- * Mirrors the persisted columns (see `db/schema.ts` `polymarketTradeHistory`).
- */
-export interface StoredTrade {
-    /** Trader wallet address (`trader_id`). */
-    traderId: string;
-    /** Market condition id (`condition_id`). */
-    conditionId: string;
-    /** Activity type; only `"TRADE"` rows are reconstructed. */
-    type: string;
-    /** `"BUY"` or `"SELL"` for a TRADE; other values are treated as missing. */
-    side: string | null;
-    /** Outcome leg (0 or 1). */
-    outcomeIndex: number | null;
-    /** Number of shares/tokens in the fill (must be finite and > 0). */
-    size: number;
-    /** USDC cash moved by the fill (must be finite and >= 0). */
-    usdcSize: number;
-    /** Trade execution time, epoch seconds (must be finite). */
-    timestamp: number;
-    /**
-     * Optional stable row id (the `transaction_hash-outcomeIndex` primary key).
-     * Not used for ordering; carried only to make skip reports traceable.
-     */
-    id?: string;
-}
-/** Why a row or group could not be reconstructed into a resolved position. */
-export type ReconstructionSkipReason = 
-/** Row `type` is not `"TRADE"` (e.g. REDEEM/SPLIT/MERGE); not a bet fill. */
-"non-trade-type"
-/**
- * A required field was missing or non-finite.
- *
- * For a row whose grouping key is itself usable, the WHOLE group is skipped —
- * including any episodes in that group that had already cleanly opened and
- * closed. This is deliberately more aggressive than the oversell policy, and
- * the reason is that a malformed row is dropped BEFORE its timeline position
- * is recorded, so its true place among the group's fills is unknown. An
- * episode that looks "earlier" among the remaining valid fills might actually
- * have had the malformed fill interleaved inside it, so no episode in the
- * group can be proven to precede the bad row. Discarding the whole group never
- * emits a misleading value; it only drops data we cannot place with certainty.
- * (Contrast `oversold`, whose offending SELL has a known timestamp, so
- * independently completed earlier episodes are retained.)
- *
- * For a row whose grouping key is unusable the single row is skipped (and may
- * silently under-count its group — undetectable here).
- */
- | "missing-fields"
-/**
- * A SELL arrived in an episode that had no recorded BUY inventory. Detected at
- * a known point in the ordered fills, so any independently completed earlier
- * episodes in the same group are retained.
- */
- | "no-buys"
-/**
- * A SELL exceeded the inventory tracked so far (missing earlier BUYs).
- * Detected at a known point in the ordered fills, so any independently
- * completed earlier episodes in the same group are retained; only this
- * episode onward is abandoned.
- */
- | "oversold";
-/** One skipped row or group, with the reason and a traceable key. */
-export interface ReconstructionSkip {
-    /**
-     * Group key `traderId:conditionId:outcomeIndex` for group-level skips, or a
-     * row locator (`row <id>` / `row #<index>`) for row-level skips.
-     */
-    key: string;
-    reason: ReconstructionSkipReason;
-}
-/** Result of {@link reconstructResolvedPositions}. */
-export interface ReconstructionResult {
-    /**
-     * Reconstructed positions in deterministic order (grouped, then by episode).
-     * Fully SELL-closed episodes have `resolved: true`; a group's trailing
-     * residual inventory is emitted once with `resolved: false`. Ready to pass to
-     * `rMultiplesFromResolvedPositions`.
-     */
-    positions: ResolvedPosition[];
-    /** Every skipped row/group, in the order encountered. */
-    skipped: ReconstructionSkip[];
-}
-/** Options for {@link reconstructResolvedPositions}. */
-export interface ReconstructionOptions {
-    /**
-     * Absolute tolerance, in shares, for treating residual inventory as flat.
-     * Used ONLY to absorb floating-point dust from summing `size`:
-     *   - `|inventory| <= sharesEpsilon`  -> treated as exactly flat (episode closes),
-     *   - `inventory < -sharesEpsilon`    -> oversell,
-     *   - `inventory >  sharesEpsilon`    -> material open inventory (stays unresolved).
-     * It never rounds away a material mismatch: anything above the epsilon is
-     * real inventory, not dust. Defaults to `1e-9`. Must be finite and >= 0.
-     *
-     * CAUTION: this is a dust tolerance, not a rounding knob. It is validated only
-     * as finite and non-negative — there is no universal upper bound, because the
-     * meaningful share scale varies by market. A caller that passes an excessively
-     * large value (e.g. tens or hundreds of shares) WILL cause genuinely material
-     * residual inventory to be classified as flat, emitting a bogus `resolved`
-     * position (and masking a real oversell). Keep it at or near the default;
-     * raise it only by an amount provably within float-summation error.
-     */
-    sharesEpsilon?: number;
-}
-/** Default dust tolerance for the flat/oversell inventory test. */
-export declare const DEFAULT_SHARES_EPSILON = 1e-9;
-/**
- * Reconstructs completed Polymarket positions from stored TRADE rows.
- *
- * Fills are grouped by `(traderId, conditionId, outcomeIndex)` and, within a
- * group, sorted by `timestamp` ascending. TIE-BREAK: fills sharing a timestamp
- * keep their original input order (a stable sort). Because Polymarket
- * timestamps are second-granularity, several fills in the same second have an
- * ambiguous true execution order; this function does not attempt to recover it,
- * so for same-second fills the episode split (and any oversell classification)
- * depends on the order the caller supplied. Pass rows in a consistent order
- * (e.g. the DB's `ORDER BY timestamp, id`) for reproducible results; the
- * function is otherwise fully deterministic and does not read the clock.
- *
- * @param trades - Stored trade rows (a superset of TRADE rows is fine; non-TRADE
- *   rows are reported as `non-trade-type` skips and ignored).
- * @param options - See {@link ReconstructionOptions}.
- * @returns A {@link ReconstructionResult}.
- * @throws {TypeError} If `trades` is not an array.
- * @throws {RangeError} If `sharesEpsilon` is supplied and is not finite / is negative.
- */
-export declare function reconstructResolvedPositions(trades: readonly StoredTrade[], options?: ReconstructionOptions): ReconstructionResult;
-//# sourceMappingURL=position-reconstruction.d.ts.map

package/dist/prediction/analysis/position-reconstruction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"position-reconstruction.d.ts","sourceRoot":"","sources":["../../../src/prediction/analysis/position-reconstruction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,4BAA4B;IAC5B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,8EAA8E;AAC9E,MAAM,MAAM,wBAAwB;AAClC,6EAA6E;AAC3E,gBAAgB;AAClB;;;;;;;;;;;;;;;;;GAiBG;GACD,gBAAgB;AAClB;;;;GAIG;GACD,SAAS;AACX;;;;;GAKG;GACD,UAAU,CAAC;AAEf,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,wBAAwB,CAAC;CAClC;AAED,sDAAsD;AACtD,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,yDAAyD;IACzD,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAED,wDAAwD;AACxD,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;;;;OAgBG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,mEAAmE;AACnE,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAmB3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,CAkKtB"}

package/dist/prediction/analysis/position-settlement.d.ts

@@ -1,99 +0,0 @@
-import { ResolvedPosition } from './r-multiple';
-import { ReconstructionSkip, StoredTrade } from './position-reconstruction';
-/**
- * An explicit, point-in-time market resolution label for one condition. Supplied
- * by the (impure) caller; this module never derives it from market state.
- */
-export interface MarketResolution {
-    /**
-     * Index of the outcome leg that resolved true. This is a BINARY-market
-     * converter, so only `0` or `1` is accepted; any other value (a sentinel,
-     * a multi-outcome index, a garbage label) is rejected and the affected
-     * position is left unresolved rather than settled or marked a false loss.
-     */
-    winningOutcomeIndex: number;
-    /**
-     * Epoch seconds at which the market resolved (the settlement instant). Must be
-     * at or after every fill of the settled episode — a market cannot resolve
-     * before its last contributing trade. A `resolvedAt` earlier than that leaves
-     * the position unresolved (never settled with an impossible, look-ahead time).
-     */
-    resolvedAt: number;
-}
-/** How a {@link SettledPosition} reached its final state. */
-export type PositionClosure = "sell-close" | "settlement" | "open";
-/**
- * A reconstructed position, tagged with how it closed. Adds fields to
- * {@link ResolvedPosition} (so it remains assignable to it and usable directly
- * with `rMultiplesFromResolvedPositions`) without changing that contract.
- */
-export interface SettledPosition extends ResolvedPosition {
-    /** Whether this was SELL-closed, settled at resolution, or still open. */
-    closure: PositionClosure;
-    /**
-     * Residual shares at resolution — present for `"settlement"` and `"open"`
-     * positions, `undefined` for `"sell-close"` (which returned to flat).
-     */
-    residualShares?: number;
-}
-/** Result of {@link settleResolvedPositions}. */
-export interface SettlementResult {
-    /**
-     * Positions in deterministic order (grouped, then by episode). Pass directly
-     * to `rMultiplesFromResolvedPositions`; `"open"` entries are excluded there
-     * as `unresolved`.
-     */
-    positions: SettledPosition[];
-    /** Skipped rows/groups, mirroring reconstruction's reasons. */
-    skipped: ReconstructionSkip[];
-}
-/** A resolution lookup keyed by `conditionId`. */
-export type ResolutionMap = ReadonlyMap<string, MarketResolution>;
-/** Options for {@link settleResolvedPositions}. */
-export interface SettlementOptions {
-    /**
-     * Dust tolerance in shares for the flat/oversell inventory test. Identical in
-     * meaning to reconstruction's option: see its docs for the caution that an
-     * excessively large value misclassifies material inventory. Defaults to
-     * {@link DEFAULT_SHARES_EPSILON}. Must be finite and >= 0.
-     */
-    sharesEpsilon?: number;
-}
-/**
- * Reconstructs Polymarket positions from stored TRADE fills and settles residual
- * inventory against explicit resolution labels.
- *
- * Fills are grouped by `(traderId, conditionId, outcomeIndex)` and sorted by
- * `timestamp` (stable; equal timestamps keep input order — see
- * {@link reconstructResolvedPositions} for the same tie-break caveat). SELL-
- * closed episodes are emitted as `"sell-close"`. A group's trailing residual
- * inventory is settled as `"settlement"` only when `resolutions` has a label for
- * its `conditionId` that is both (a) a valid BINARY label — `winningOutcomeIndex`
- * exactly 0 or 1, finite `resolvedAt` — and (b) temporally consistent —
- * `resolvedAt` at or after the latest fill of that episode. Otherwise the
- * residual is left `"open"` (unresolved); an unsupported index or an impossible
- * early `resolvedAt` never produces a resolved position or a fabricated $0 loss.
- * A fill whose `outcomeIndex` is not 0 or 1 is rejected as an invalid row
- * (`missing-fields`), not silently grouped. A position is ever only one of these
- * — a closed episode or the trailing residual — so it is never both SELL-closed
- * and settlement-resolved.
- *
- * DE-DUPLICATION: fills are de-duplicated by the verified trade identity — the
- * `id` field, which is the `polymarket_trade_history` primary key
- * `transaction_hash-outcomeIndex`. Two rows sharing a non-empty `id` denote the
- * SAME on-chain fill (the DB enforces uniqueness on it), so only the first is
- * counted and later copies are dropped. Rows WITHOUT an `id` cannot be
- * identified as duplicates and are each counted; de-duplicating those is a
- * caller precondition.
- *
- * @param trades - Stored trade rows (non-TRADE rows are reported as
- *   `non-trade-type` skips and ignored).
- * @param resolutions - Resolution labels keyed by `conditionId`. An empty map
- *   (or a missing/invalid entry) leaves the affected residual positions open.
- * @param options - See {@link SettlementOptions}.
- * @returns A {@link SettlementResult}.
- * @throws {TypeError} If `trades` is not an array or `resolutions` is not a Map.
- * @throws {RangeError} If `sharesEpsilon` is supplied and is not finite / is negative.
- */
-export declare function settleResolvedPositions(trades: readonly StoredTrade[], resolutions: ResolutionMap, options?: SettlementOptions): SettlementResult;
-//# sourceMappingURL=position-settlement.d.ts.map

package/dist/prediction/analysis/position-settlement.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"position-settlement.d.ts","sourceRoot":"","sources":["../../../src/prediction/analysis/position-settlement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAEnC;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,6DAA6D;AAC7D,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,YAAY,GAAG,MAAM,CAAC;AAEnE;;;;GAIG;AACH,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD,0EAA0E;IAC1E,OAAO,EAAE,eAAe,CAAC;IACzB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,iDAAiD;AACjD,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,+DAA+D;IAC/D,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAED,kDAAkD;AAClD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAElE,mDAAmD;AACnD,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAkDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,WAAW,EAAE,aAAa,EAC1B,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CA0LlB"}

package/dist/prediction/analysis/r-multiple.d.ts

@@ -1,159 +0,0 @@
-/**
- * R-multiple conversion for resolved prediction-market positions.
- *
- * A pure, deterministic utility that turns a list of already-reconstructed,
- * fully-realized positions into the per-trade R-multiples consumed by
- * {@link computeForecasterTrustScore} (see `./trust-score.ts`). An R-multiple
- * expresses a position's realized profit or loss in units of the risk taken:
- *
- *     R = netRealizedPnl / initialRisk
- *
- * where `initialRisk` is the net premium paid to open the position (the most
- * that can be lost, since a prediction-market share's downside is bounded at
- * zero). A position that loses its entire stake therefore scores exactly -1R,
- * matching the research paper's convention (§3.2).
- *
- * BOUNDARY: this module sits at the clean edge of the pipeline. It performs NO
- * I/O, DB, network, or clock access; it does NOT reconstruct positions from raw
- * trade history, ingest settlement/redemption events, impute resolution
- * outcomes, size positions, or place orders. All of that is upstream, impure
- * work that produces the {@link ResolvedPosition} array this function consumes.
- * A `cutoff` is passed in, never read from the system clock, so the function
- * stays referentially transparent and leak-free: a Trust Score at a historical
- * cutoff must only see outcomes known by that cutoff, and the caller enforces
- * that by supplying the cutoff here.
- *
- * Error philosophy mirrors `trust-score.ts`: malformed INPUT SHAPES throw
- * (programmer error), while DATA-QUALITY problems in otherwise well-formed
- * records (unresolved, non-finite financials, non-positive risk, timestamps
- * after the cutoff) are reported as soft exclusions, never thrown and never
- * silently coerced. Every value in the returned `rMultiples` is a finite
- * number, so the downstream Trust Score never has to defend against NaN/Infinity.
- */
-/** Why a {@link ResolvedPosition} was dropped from the R-multiple sample. */
-export type RMultipleExclusionReason = 
-/** `resolved === false`: the position is still open / not yet realized. */
-"unresolved"
-/**
- * `initialRisk` is at or below the accepted floor (`<= minInitialRisk`,
- * default `0`). Includes the zero-risk divide-by-zero case; no R is emitted
- * rather than an infinite one.
- */
- | "non-positive-risk"
-/**
- * `netRealizedPnl` or `initialRisk` is not a finite number, or the computed
- * R-multiple overflowed to a non-finite value.
- */
- | "non-finite"
-/**
- * A `cutoff` was supplied but the position's `resolutionTimestamp` is `null`
- * or non-finite, so it cannot be placed relative to the cutoff.
- */
- | "missing-timestamp"
-/**
- * A `cutoff` was supplied and `resolutionTimestamp > cutoff`: the outcome was
- * not known by the cutoff, so including it would leak future information.
- */
- | "after-cutoff";
-/** Every exclusion reason, in a fixed order, for zero-filling tallies. */
-export declare const R_MULTIPLE_EXCLUSION_REASONS: readonly RMultipleExclusionReason[];
-/**
- * One completed (fully realized) prediction-market position, already netted by
- * the upstream impure adapter. The YES/NO distinction does not appear here: it
- * is folded into the signed `netRealizedPnl` and the `initialRisk` before this
- * function sees it.
- */
-export interface ResolvedPosition {
-    /** Stable identifier, e.g. `${trader}:${conditionId}:${outcomeIndex}`. */
-    positionId: string;
-    /**
-     * Net realized profit or loss in USDC: sale proceeds + settlement redemptions
-     * minus entry cost minus fees. May be negative, or exactly `0` (break-even).
-     */
-    netRealizedPnl: number;
-    /**
-     * Initial risk in USDC: the net premium paid to open the position. Must be
-     * strictly positive (and above `minInitialRisk`) to be usable as the R
-     * denominator.
-     */
-    initialRisk: number;
-    /**
-     * Whether the position's P&L is fully realized — either the market settled at
-     * resolution or the position was fully exited early. Open positions
-     * (`false`) are never scored.
-     */
-    resolved: boolean;
-    /**
-     * Epoch seconds at which the realized P&L became known (settlement time, or
-     * the final exit trade's time). Required (finite) for cutoff gating; `null`
-     * when the position is unresolved or the time is unknown.
-     */
-    resolutionTimestamp: number | null;
-}
-/** A single dropped position and the reason it was dropped. */
-export interface ExcludedPosition {
-    positionId: string;
-    /** The reason; never the implicit "included" state. */
-    reason: RMultipleExclusionReason;
-}
-/** Options for {@link rMultiplesFromResolvedPositions}. */
-export interface RMultipleOptions {
-    /**
-     * Historical cutoff in epoch seconds. When supplied, only positions whose
-     * `resolutionTimestamp` is finite and `<= cutoff` are included; the rest are
-     * excluded as `after-cutoff` or `missing-timestamp`. Omitted means no gate.
-     */
-    cutoff?: number;
-    /**
-     * Exclusive lower bound on `initialRisk` (USDC). A position is usable only
-     * when `initialRisk > minInitialRisk`. Defaults to `0`, so any strictly
-     * positive risk is accepted. Must be a finite, non-negative number.
-     */
-    minInitialRisk?: number;
-}
-/** Result of {@link rMultiplesFromResolvedPositions}. */
-export interface RMultipleConversion {
-    /**
-     * Finite R-multiples for the included positions, in the order they appeared
-     * in the input. Ready to pass straight to `computeForecasterTrustScore`.
-     */
-    rMultiples: number[];
-    /** Number of included positions; always equals `rMultiples.length`. */
-    included: number;
-    /** One entry per dropped position, in input order, with its reason. */
-    excluded: ExcludedPosition[];
-    /**
-     * Count of exclusions per reason. Every {@link RMultipleExclusionReason} key
-     * is present and zero-filled, so callers can read any reason without a guard.
-     */
-    excludedCounts: Record<RMultipleExclusionReason, number>;
-}
-/**
- * Converts resolved prediction-market positions into per-position R-multiples,
- * reporting every position that is dropped and why.
- *
- * Soft exclusions are evaluated in a fixed precedence; the first failing check
- * wins, so each dropped position carries exactly one reason:
- *   1. `unresolved`         — `resolved === false`.
- *   2. `missing-timestamp`  — a `cutoff` is set but `resolutionTimestamp` is
- *                             `null`/non-finite.
- *   3. `after-cutoff`       — a `cutoff` is set and `resolutionTimestamp > cutoff`.
- *   4. `non-finite` (risk)  — `initialRisk` is NaN or ±Infinity (checked before
- *                             the threshold, so `+Infinity` cannot slip through).
- *   5. `non-positive-risk`  — finite `initialRisk <= minInitialRisk`.
- *   6. `non-finite` (P&L)   — `netRealizedPnl` is NaN or ±Infinity.
- *   7. `non-finite` (R)     — the finite division overflowed to a non-finite R.
- *
- * @param positions - Completed positions produced by the upstream adapter.
- * @param options - See {@link RMultipleOptions}.
- * @returns A {@link RMultipleConversion}: the finite R-multiples (input order),
- *   the included count, the excluded positions with reasons, and a zero-filled
- *   per-reason tally.
- * @throws {TypeError} If `positions` is not an array, or any element is not a
- *   well-formed {@link ResolvedPosition} (missing/ wrong-typed `positionId`,
- *   `netRealizedPnl`, `initialRisk`, `resolved`, or `resolutionTimestamp`).
- * @throws {RangeError} If `cutoff` is supplied and is not finite, or
- *   `minInitialRisk` is supplied and is not a finite, non-negative number.
- */
-export declare function rMultiplesFromResolvedPositions(positions: readonly ResolvedPosition[], options?: RMultipleOptions): RMultipleConversion;
-//# sourceMappingURL=r-multiple.d.ts.map

package/dist/prediction/analysis/r-multiple.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"r-multiple.d.ts","sourceRoot":"","sources":["../../../src/prediction/analysis/r-multiple.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,6EAA6E;AAC7E,MAAM,MAAM,wBAAwB;AAClC,2EAA2E;AACzE,YAAY;AACd;;;;GAIG;GACD,mBAAmB;AACrB;;;GAGG;GACD,YAAY;AACd;;;GAGG;GACD,mBAAmB;AACrB;;;GAGG;GACD,cAAc,CAAC;AAEnB,0EAA0E;AAC1E,eAAO,MAAM,4BAA4B,EAAE,SAAS,wBAAwB,EAM3E,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,MAAM,EAAE,wBAAwB,CAAC;CAClC;AAED,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC;CAC1D;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,OAAO,GAAE,gBAAqB,GAC7B,mBAAmB,CA2GrB"}

package/dist/prediction/analysis/trust-score.d.ts

@@ -1,158 +0,0 @@
-/**
- * Forecaster Trust Score.
- *
- * A pure, deterministic implementation of the "Forecaster Trust Score"
- * described in the AI Broker research paper
- * (`apps/ai-broker-web/content/docs/agents/ai-broker-research-paper.md`, §3.2),
- * which extends the per-trade Sharpe ratio with a sample-size confidence term so
- * that a long, consistent track record is trusted more than a short, lucky one.
- *
- * Stated formula (paper §3.2):
- *
- *     Trust = (meanR / stdR) * sqrt(N)
- *
- * where
- *   - meanR = mean R-multiple per resolved trade (edge per unit of risk),
- *   - stdR  = standard deviation of R-multiples (consistency),
- *   - N     = number of resolved trades (sample size).
- *
- * The leading `meanR / stdR` factor is the per-trade Sharpe ratio; `sqrt(N)` is
- * the standard-error amplification that rewards larger samples. A forecaster
- * with zero mean R-multiple scores zero regardless of N (paper §3.2.3), which is
- * the no-edge baseline that distinguishes skill from luck.
- *
- * This module only computes the score. It deliberately does NOT read trades from
- * a database or API, resolve markets, size positions, or place orders — it is a
- * self-contained numeric function with no network, no clock, and no execution
- * side effects, so it can be unit-tested and reasoned about in isolation.
- *
- * NOTE ON THE PAPER'S WORKED TABLE: the example table in §3.2 (forecasters
- * P1–P10) is internally inconsistent for three rows. P5, P6 and P7 print a
- * `Trust` value that disagrees with the paper's own `Sharpe` column and with the
- * stated formula `Sharpe * sqrt(N)` (e.g. P7: 0.46 * sqrt(120) = 5.07, not the
- * printed 4.00). The other seven rows agree with the formula to within rounding.
- * This implementation follows the stated formula; the test file documents each
- * discrepancy explicitly.
- */
-/** Why a score is (or is not) reliable. See {@link ForecasterTrustScore}. */
-export type TrustScoreReason = 
-/** Score computed and sample size meets the minimum — safe to rely on. */
-"ok"
-/** No trades supplied; nothing to score. */
- | "empty"
-/** Score computed, but fewer than `minSampleSize` trades — treat as weak. */
- | "insufficient-sample"
-/**
- * R-multiples have zero dispersion while the mean is non-zero, so the
- * Sharpe ratio (and therefore the score) is undefined rather than infinite.
- */
- | "zero-variance"
-/**
- * R-multiples have zero dispersion AND a zero mean (every trade identical,
- * e.g. an all-zero / all-break-even history). There is no edge and no spread
- * to measure, so this carries no information — not a reliable zero.
- */
- | "no-information"
-/**
- * Inputs were individually finite but their sum or dispersion overflowed to
- * a non-finite value, so no finite score exists.
- */
- | "overflow";
-/** Options for {@link computeForecasterTrustScore}. */
-export interface ForecasterTrustScoreOptions {
-    /**
-     * Minimum number of resolved trades for a score to be considered reliable.
-     * Defaults to 25, matching the `N >= 25` threshold used throughout the paper.
-     * A score is still computed below this, but is flagged `reliable: false`.
-     */
-    minSampleSize?: number;
-    /**
-     * Delta degrees of freedom for the standard deviation of R-multiples:
-     *   - `1` (default): sample standard deviation (divides the sum of squared
-     *     deviations by `N - 1`), matching the finance Sharpe-ratio convention the
-     *     paper's Sharpe column is built on.
-     *   - `0`: population standard deviation (divides by `N`).
-     * With a single trade (`N - ddof <= 0`) the dispersion is not estimable and is
-     * treated as zero variance.
-     */
-    ddof?: 0 | 1;
-}
-/** Result of {@link computeForecasterTrustScore}. */
-export interface ForecasterTrustScore {
-    /**
-     * The Trust Score `(meanR / stdR) * sqrt(N)`, or `null` when it is not finitely
-     * defined (no trades, zero dispersion, or overflow). Never `NaN` or `Infinity`.
-     */
-    score: number | null;
-    /**
-     * Whether `score` is a finite number — i.e. the formula is mathematically
-     * defined for this input. Independent of sample size. Equivalent to
-     * `score !== null`.
-     */
-    isDefined: boolean;
-    /**
-     * Whether `sampleSize >= minSampleSize` — i.e. there is enough evidence to
-     * trust the number. Independent of whether the score is defined.
-     */
-    hasSufficientSample: boolean;
-    /**
-     * Safe to act on: `isDefined && hasSufficientSample`. A single flag for the
-     * common "should I use this?" check; inspect `isDefined` / `hasSufficientSample`
-     * (or `reason`) to see which condition failed.
-     */
-    reliable: boolean;
-    /** Number of resolved trades used (array length). */
-    sampleSize: number;
-    /** Mean R-multiple. `0` when there are no trades. */
-    meanR: number;
-    /** Standard deviation of R-multiples under `ddof`. `0` when undefined. */
-    stdR: number;
-    /** Per-trade Sharpe ratio `meanR / stdR`, or `null` when `stdR` is `0`. */
-    sharpe: number | null;
-    /** Machine-readable explanation of `score` / `reliable`. */
-    reason: TrustScoreReason;
-    /** The effective minimum sample size used for the reliability decision. */
-    minSampleSize: number;
-}
-/** Default minimum resolved-trade count for a reliable score (paper: N >= 25). */
-export declare const DEFAULT_MIN_SAMPLE_SIZE = 25;
-/**
- * Computes the Trust Score directly from pre-aggregated moments.
- *
- * This is the exact formula `(meanR / stdR) * sqrt(sampleSize)` with safe
- * handling of the degenerate cases, kept separate from
- * {@link computeForecasterTrustScore} so callers that already have summary
- * statistics (for example, the paper's worked table) can use it without
- * reconstructing a per-trade array.
- *
- * @param meanR - Mean R-multiple.
- * @param stdR - Standard deviation of R-multiples (must be `>= 0`).
- * @param sampleSize - Number of resolved trades (non-negative integer).
- * @returns The finite Trust Score, or `null` when it is undefined: no trades
- *   (`sampleSize === 0`) or zero dispersion (`stdR === 0`, including a zero mean
- *   — the t-statistic needs non-zero sample variance). A zero mean with POSITIVE
- *   variance scores `0` (no edge), per the paper. Never `NaN`/`Infinity`.
- * @throws {TypeError} If any argument is not a finite number.
- * @throws {RangeError} If `sampleSize` is negative or non-integer, or `stdR < 0`.
- */
-export declare function trustScoreFromMoments(meanR: number, stdR: number, sampleSize: number): number | null;
-/**
- * Computes a {@link ForecasterTrustScore} from a forecaster's resolved-trade
- * R-multiples.
- *
- * Each element is one resolved trade's R-multiple (profit or loss expressed in
- * units of the risk taken on that trade). The caller is responsible for turning
- * raw trade history into R-multiples; this function performs no resolution,
- * I/O, or time-dependent work.
- *
- * @param rMultiples - Finite R-multiples, one per resolved trade.
- * @param options - See {@link ForecasterTrustScoreOptions}.
- * @returns A fully populated {@link ForecasterTrustScore}. Insufficient evidence
- *   is reported via `reliable`/`reason`, never hidden behind a bare number.
- * @throws {TypeError} If `rMultiples` is not an array or contains a non-finite
- *   value.
- * @throws {RangeError} If `minSampleSize` is not a positive integer, or `ddof`
- *   is not `0` or `1`.
- */
-export declare function computeForecasterTrustScore(rMultiples: readonly number[], options?: ForecasterTrustScoreOptions): ForecasterTrustScore;
-//# sourceMappingURL=trust-score.d.ts.map

package/dist/prediction/analysis/trust-score.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trust-score.d.ts","sourceRoot":"","sources":["../../../src/prediction/analysis/trust-score.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB;AAC1B,0EAA0E;AACxE,IAAI;AACN,4CAA4C;GAC1C,OAAO;AACT,6EAA6E;GAC3E,qBAAqB;AACvB;;;GAGG;GACD,eAAe;AACjB;;;;GAIG;GACD,gBAAgB;AAClB;;;GAGG;GACD,UAAU,CAAC;AAEf,uDAAuD;AACvD,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACd;AAED,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,4DAA4D;IAC5D,MAAM,EAAE,gBAAgB,CAAC;IACzB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,kFAAkF;AAClF,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,IAAI,CAqBf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,GAAE,2BAAgC,GACxC,oBAAoB,CAuFtB"}

package/dist/prediction/sync/refill-limits.d.ts

@@ -1,9 +0,0 @@
-/**
- * Refill size limits, kept apart from refill.ts so callers that only validate
- * input (route handlers, tests) do not import the database client.
- */
-/** Upper bound an admin refill may request, so one click cannot run all night. */
-export declare const MAX_REFILL_MARKETS = 5000;
-/** Clamps a requested refill size to 1…MAX_REFILL_MARKETS (0 or junk → default). */
-export declare function clampRefillSize(value: unknown, fallback?: number): number;
-//# sourceMappingURL=refill-limits.d.ts.map

package/dist/prediction/sync/refill-limits.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"refill-limits.d.ts","sourceRoot":"","sources":["../../../src/prediction/sync/refill-limits.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,kFAAkF;AAClF,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAM,GAAG,MAAM,CAItE"}