@insiderfinance/totalfinance 0.1.0

package/modules/performance/src/sharpe.ts

@@ -0,0 +1,256 @@
+/**
+ * `@insiderfinance/totalfinance/performance/sharpe` — the Sharpe ratio and annualized volatility.
+ *
+ * This deep entrypoint imports only `@insiderfinance/totalfinance/math` (mean/stddev) and tiny `@insiderfinance/totalfinance/core` facade
+ * plumbing — never options, fixed-income, risk, or data packages — so computing a Sharpe ratio stays
+ * import-light (spec §15.1).
+ *
+ * Each metric is a facade (design law #3): the plain call returns a bare number; `.explain()` returns
+ * the `Computed` envelope echoing the annualization factor (and, where used, the risk-free rate) it
+ * applied — so a defaulted `periodsPerYear: 252` is disclosed, never hidden.
+ */
+
+import {
+  requireFiniteFields,
+  CONVENTIONS_VERSION,
+  type Assumptions,
+  type Computed,
+  type Diagnostics,
+  ErrorCode,
+  InputError,
+  seriesFacade,
+  suspiciousReturnsWarning,
+  warning,
+  WarningCode,
+  finiteOrNull,
+  ensureKnownKeys,
+  requireArgumentObject,
+} from '@totalfinance/core';
+import { resolvePeriodsPerYear, resolveRiskFreeRate } from './annualization-internal.js';
+import { mean, standardDeviation } from '@totalfinance/math';
+
+/**
+ * Boundary guard for every series-consuming performance facade (dx §1.2 applied here): the input
+ * must be a real array (or typed array) of numbers — a string, `undefined`, or a plain object
+ * throws a typed teaching error instead of a raw `TypeError` from `series.length` downstream.
+ * The container being an array is not enough: EVERY element is validated (E4) — a single NaN,
+ * `undefined`, or string mid-series poisons a mean/stddev into a silently-wrong number, and a
+ * `sharpe([0.01, NaN, 0.02])` masquerading as a real ratio is exactly the corruption Law 7 kills
+ * at the boundary. A `Float64Array` of finite values always passes; empty arrays keep their
+ * documented null-with-reason behavior downstream.
+ */
+export function requireSeries(
+  series: ArrayLike<number>,
+  functionName: string,
+  field = 'returns',
+): void {
+  // This validator is itself public API: a garbled functionName would emit teaching that names no
+  // function, so it runs its own ladder first.
+  if (typeof functionName !== 'string' || functionName.length === 0) {
+    throw new InputError(
+      `requireSeries: functionName must be a non-empty string naming the boundary being validated. Received ${functionName === undefined ? 'undefined' : functionName === null ? 'null' : typeof functionName}.`,
+      { code: ErrorCode.InputWrongType, context: { functionName } },
+    );
+  }
+  if (!Array.isArray(series) && !ArrayBuffer.isView(series)) {
+    const received = series === null ? 'null' : typeof series;
+    throw new InputError(
+      `${functionName}: ${field} must be an array of numbers (got ${received}). e.g. ${functionName}([0.01, -0.02, 0.015])`,
+      { code: ErrorCode.InputWrongType, context: { function: functionName, field, received } },
+    );
+  }
+  for (let i = 0; i < series.length; i++) {
+    const v: unknown = series[i];
+    if (typeof v !== 'number' || !Number.isFinite(v)) {
+      const received = typeof v === 'number' ? String(v) : typeof v;
+      throw new InputError(
+        `${functionName}: ${field}[${i}] must be a finite number (got ${received}) — a non-finite value would silently poison every metric. ${functionName} expects per-period decimal returns, e.g. ${functionName}([0.01, -0.02, 0.015]).`,
+        {
+          // Wrong CONTAINER content (a string) is a type error; a NaN/Infinity NUMBER is not-finite.
+          code: typeof v === 'number' ? ErrorCode.InputNotFinite : ErrorCode.InputWrongType,
+          context: { function: functionName, field, index: i, received },
+        },
+      );
+    }
+  }
+}
+
+/**
+ * The daily-data annualization convention. It is an industry constant (252 trading days), not a
+ * hidden finance choice — so it DEFAULTS when omitted and is echoed back in the result's assumptions.
+ * Use 12 for monthly data, 52 for weekly.
+ */
+export const DEFAULT_PERIODS_PER_YEAR = 252;
+
+export interface AnnualizationOptions {
+  /** Periods per year for annualization. Defaults to 252 (daily); pass 12 monthly, 52 weekly. */
+  periodsPerYear?: number;
+}
+
+/** Law 12 allowlist for {@link AnnualizationOptions} — a `periodsPeryear` typo teaches, never silently annualizes at 252. */
+export const ANNUALIZATION_KEYS = ['periodsPerYear'] as const;
+
+export interface SharpeOptions extends AnnualizationOptions {
+  /** Annualized risk-free rate (decimal, default 0). */
+  riskFreeRate?: number;
+}
+
+/** Law 12 allowlist for {@link SharpeOptions} — the parent's keys plus the risk-free rate. */
+export const SHARPE_KEYS = [...ANNUALIZATION_KEYS, 'riskFreeRate'] as const;
+
+/** Conventions disclosed by an annualization-only metric. */
+export type AnnualizationExtra = { periodsPerYear: number };
+/** Conventions disclosed by a risk-adjusted (excess-return) metric. */
+export type RiskAdjustedExtra = { periodsPerYear: number; riskFreeRate: number };
+
+/** Assumptions echoing just the annualization factor. */
+export function annualizationAssumptions(periodsPerYear: number): Assumptions<AnnualizationExtra> {
+  return { conventionsVersion: CONVENTIONS_VERSION, periodsPerYear };
+}
+
+/** Assumptions echoing the annualization factor and the applied risk-free rate. */
+export function riskAdjustedAssumptions(input: RiskAdjustedExtra): Assumptions<RiskAdjustedExtra> {
+  requireArgumentObject('riskAdjustedAssumptions', 'input', input);
+  ensureKnownKeys('riskAdjustedAssumptions', 'input', input, ['periodsPerYear', 'riskFreeRate']);
+  // What lands here is DISCLOSED as the applied conventions — a null or string smuggled into
+  // `assumptions` would be served to the caller as truth.
+  requireFiniteFields('riskAdjustedAssumptions', input, ['periodsPerYear', 'riskFreeRate'], {
+    exampleCall: 'riskAdjustedAssumptions({ periodsPerYear: 252, riskFreeRate: 0.04 })',
+  });
+  const { periodsPerYear, riskFreeRate } = input;
+  return { conventionsVersion: CONVENTIONS_VERSION, periodsPerYear, riskFreeRate };
+}
+
+/**
+ * Diagnostics for a returns-consuming explain path (dx WS-3/R6): flags any input series whose
+ * values look like prices rather than per-period decimal returns. Shared by every returns-typed
+ * metric in this package (and risk); equity/price-typed parameters must NOT use it.
+ */
+export function returnsDiagnostics(...series: ArrayLike<number>[]): Diagnostics {
+  // Publicly reachable via the /sharpe subpath: a non-series argument yields no diagnostics
+  // rather than a raw crash (the metric facades validate the series before ever calling this).
+  series = series.filter((s) => s !== null && typeof s === 'object' && 'length' in s);
+  const warnings = [];
+  for (const s of series) {
+    const w = suspiciousReturnsWarning(s);
+    if (w !== undefined) {
+      warnings.push(w);
+      break; // one warning is enough to make the point
+    }
+  }
+  return { warnings };
+}
+
+/**
+ * Degenerate-NaN honesty (design law #4: a NaN result must ride with an explicit diagnostic, never
+ * alone). Wraps {@link returnsDiagnostics} and — when the computed `value` is NaN — appends a
+ * `WarningCode.DegenerateInput` warning saying WHY the metric is undefined for this input. Used by
+ * the `.explain()` paths only; plain calls stay silent-and-correct (they still return the NaN).
+ * Pass no `series` for non-returns inputs (e.g. weight rows) where the prices-as-returns
+ * plausibility scan must not apply.
+ */
+export function degenerateAwareDiagnostics(
+  value: number,
+  functionName: string,
+  reason: string,
+  ...series: ArrayLike<number>[]
+): Diagnostics {
+  // `value` may legitimately be NaN/±Infinity — that is the case this helper explains — but it
+  // must BE a number, and the labels must be strings, or the disclosure this builds would lie.
+  if (typeof value !== 'number' || typeof functionName !== 'string' || typeof reason !== 'string') {
+    throw new InputError(
+      `degenerateAwareDiagnostics: expected (value: number, functionName: string, reason: string, ...series). Received (${typeof value}, ${typeof functionName}, ${typeof reason}).`,
+      { code: ErrorCode.InputWrongType, context: { value, functionName } },
+    );
+  }
+  const d = returnsDiagnostics(...series);
+  // Law 7 (D3): NaN AND ±Infinity are both undefined-metric cases — the facade reports null and
+  // this warning names the exact metric and why.
+  if (!Number.isFinite(value)) {
+    d.warnings.push(
+      warning(
+        WarningCode.DegenerateInput,
+        `${functionName}: the metric is undefined — ${reason}; reported as null (never NaN/Infinity).`,
+        'info',
+        {
+          function: functionName,
+          metric: functionName,
+        },
+      ),
+    );
+  }
+  return d;
+}
+
+function annualizedVolatilityValue(
+  returns: ArrayLike<number>,
+  options: AnnualizationOptions,
+): number {
+  requireSeries(returns, 'annualizedVolatility');
+  // Law 12: shared by the plain call AND `.explain()` — an unknown option teaches, never ignored.
+  ensureKnownKeys('annualizedVolatility', 'options', options, ANNUALIZATION_KEYS);
+  return (
+    standardDeviation(returns) * Math.sqrt(resolvePeriodsPerYear('annualizedVolatility', options))
+  );
+}
+
+/** Annualized volatility: per-period stddev scaled by √periodsPerYear. */
+export const annualizedVolatility = seriesFacade(
+  'annualizedVolatility',
+  (returns: ArrayLike<number>, options: AnnualizationOptions = {}): number | null =>
+    finiteOrNull(annualizedVolatilityValue(returns, options)),
+  (
+    returns: ArrayLike<number>,
+    options: AnnualizationOptions = {},
+  ): Computed<number | null, AnnualizationExtra> => {
+    const value = annualizedVolatilityValue(returns, options);
+    return {
+      value: finiteOrNull(value),
+      assumptions: annualizationAssumptions(resolvePeriodsPerYear('annualizedVolatility', options)),
+      diagnostics: degenerateAwareDiagnostics(
+        value,
+        'annualizedVolatility',
+        'the sample standard deviation needs at least 2 periods (the series is empty or has one element)',
+        returns,
+      ),
+    };
+  },
+);
+
+function sharpeRatioValue(returns: ArrayLike<number>, options: SharpeOptions): number {
+  requireSeries(returns, 'sharpe');
+  ensureKnownKeys('sharpe', 'options', options, SHARPE_KEYS);
+  const ppy = resolvePeriodsPerYear('sharpe', options);
+  const rfPerPeriod = resolveRiskFreeRate('sharpe', options) / ppy;
+  const excess = new Array<number>(returns.length);
+  for (let i = 0; i < returns.length; i++) excess[i] = returns[i]! - rfPerPeriod;
+  const sd = standardDeviation(excess);
+  if (sd === 0) return NaN;
+  return (mean(excess) / sd) * Math.sqrt(ppy);
+}
+
+/** Annualized Sharpe ratio of a per-period return series. */
+export const sharpe = seriesFacade(
+  'sharpe',
+  (returns: ArrayLike<number>, options: SharpeOptions = {}): number | null =>
+    finiteOrNull(sharpeRatioValue(returns, options)),
+  (
+    returns: ArrayLike<number>,
+    options: SharpeOptions = {},
+  ): Computed<number | null, RiskAdjustedExtra> => {
+    const value = sharpeRatioValue(returns, options);
+    return {
+      value: finiteOrNull(value),
+      assumptions: riskAdjustedAssumptions({
+        periodsPerYear: resolvePeriodsPerYear('sharpe', options),
+        riskFreeRate: resolveRiskFreeRate('sharpe', options),
+      }),
+      diagnostics: degenerateAwareDiagnostics(
+        value,
+        'sharpe',
+        'the excess returns have zero variance (or fewer than 2 periods), so there is no dispersion to divide by',
+        returns,
+      ),
+    };
+  },
+);

package/modules/portfolio/dist/allocation.d.ts

@@ -0,0 +1,227 @@
+/**
+ * `allocatePortfolio` (FC7 slice 4, Stage 4.4; tracker "Portfolio-side management" → "discrete
+ * weight-to-quantity allocation with prices, lot sizes, minimum notionals, cash reserve,
+ * transaction costs, and dust reporting"): target weights → executable quantities and cash
+ * residuals, at an explicit instant, under the ONE target-resolution law in `policy-grammar.ts`.
+ *
+ * Laws this module executes:
+ *
+ * - **Weights are of net asset value.** A target notional is `weight × netAssetValue`; the cash
+ *   target and the cash reserve are BOTH honoured (the plan intends to hold
+ *   `reserve + cashTarget × netAssetValue`). Buys are funded by cash conservation — current cash
+ *   plus sells minus the intended cash — and a plan whose buys are not funded is reported
+ *   infeasible with the shortfall; nothing is scaled silently.
+ * - **Rounding is toward zero** to the lot size (a short target rounds toward zero too: its
+ *   magnitude shrinks); every rounding residual is reported per instrument and stays in cash.
+ * - **Dust is explicit.** A trade whose notional is below `minimumNotional` is skipped, listed with
+ *   its notional and its effect on cash, and the instrument is reported at its CURRENT quantity.
+ * - **Missing goals are never defaulted.** Every unresolved target from the expansion is carried
+ *   verbatim; a target with no price, a non-positive price, or a contradiction with the policy's
+ *   allowed/restricted lists is an `unresolved` row, never a filled-in value.
+ */
+import type { EpochMs } from '../../core/dist/index.js';
+import type { CurrencyPairQuote } from './internal.js';
+import type { InstrumentClassification } from './pnl.js';
+import type { InvestmentPolicy, ResolvedTargetSource, UnresolvedTarget } from './policy-grammar.js';
+/** One instrument's price at the allocation instant, in its trading currency. */
+export interface AllocationPrice {
+    /** Finite; sign unconstrained (a target on a non-positive price is reported unresolved). */
+    price: number;
+    currency: string;
+}
+/** The transaction-cost model — every term optional and explicit; an omitted term estimates 0. */
+export interface AllocationTransactionCosts {
+    /** Base-currency commission per non-zero trade. */
+    commissionPerTrade?: number;
+    /** Base-currency commission per unit traded (× |quantity|). */
+    commissionPerUnit?: number;
+    /** Half-spread cost in basis points of |notional|. */
+    spreadBasisPoints?: number;
+    /** Market-impact/slippage cost in basis points of |notional|. */
+    slippageBasisPoints?: number;
+}
+/** The sizing grammar {@link allocatePortfolio} and `proposePortfolioRebalance` share. */
+export interface AllocationSizingInput {
+    /** Lot size per instrument (> 0, finite). */
+    lotSizes?: Record<string, number>;
+    /** Lot size for instruments without a `lotSizes` row; when neither covers an instrument its quantity stays fractional. */
+    defaultLotSize?: number;
+    /** Base-currency notional below which a trade is dust (skipped and reported). */
+    minimumNotional?: number;
+    transactionCosts?: AllocationTransactionCosts;
+}
+export interface AllocatePortfolioInput extends AllocationSizingInput {
+    /** Targets inline or via a model artifact (resolved at `asOf`). */
+    policy: InvestmentPolicy;
+    /** REQUIRED — model targets are dated; echoed on the result. */
+    asOf: EpochMs | string;
+    baseCurrency: string;
+    /** The investable total in base currency (> 0). Weights are shares of this. */
+    netAssetValue: number;
+    /** Per instrument. Required for every instrument with a target or a holding. */
+    prices: Record<string, AllocationPrice>;
+    /** FC5 quotes; required exactly when a priced instrument's currency ≠ `baseCurrency`. */
+    currencyConversions?: CurrencyPairQuote[];
+    /** Signed quantity per instrument; omitted = no holdings. */
+    currentHoldings?: Record<string, number>;
+    /**
+     * Units of the underlying per unit of quantity, per instrument (slice 5): an option's 100, a
+     * futures contract size. Omitted = 1. Notional = quantity × price × multiplier; lot rounding
+     * stays on quantity.
+     */
+    contractMultipliers?: Record<string, number>;
+    instrumentClassification?: Record<string, InstrumentClassification>;
+    /** Base currency held back from the investable amount (≥ 0), on top of the cash target. */
+    cashReserve?: number;
+}
+/** One instrument's sizing. Notionals are base currency. */
+export interface AllocationRow {
+    instrumentId: string;
+    targetWeight: number;
+    /** `targetWeight × netAssetValue`. */
+    targetNotional: number;
+    /** The supplied price, in `currency`. */
+    price: number;
+    currency: string;
+    priceInBaseCurrency: number;
+    /** Units of the underlying per unit of quantity (1 unless the caller declared a multiplier). */
+    contractMultiplier: number;
+    currentQuantity: number;
+    /** The rounded target quantity (toward zero to `lotSize`). */
+    targetQuantity: number;
+    /** `targetQuantity − currentQuantity` (signed: + buy, − sell); 0 when the trade is dust. */
+    tradeQuantity: number;
+    /** `tradeQuantity × priceInBaseCurrency` (signed). */
+    tradeNotional: number;
+    lotSize: number | null;
+    /** `(unrounded target quantity − targetQuantity) × priceInBaseCurrency` — stays in cash. */
+    roundingResidualNotional: number;
+    /** The post-trade weight of NAV (the CURRENT weight when the trade is dust). */
+    achievedWeight: number;
+    dust: boolean;
+    sourceGroups: string[];
+    implied: boolean;
+}
+export interface AllocationTrade {
+    instrumentId: string;
+    side: 'buy' | 'sell';
+    /** Unsigned magnitude. */
+    quantity: number;
+    /** `quantity × priceInBaseCurrency`, base currency. */
+    estimatedNotional: number;
+    /** The instrument's trading currency (the price's currency). */
+    currency: string;
+    /** Base-currency estimate under the cost model. */
+    estimatedCost: number;
+}
+export interface AllocationDustRow {
+    instrumentId: string;
+    /** The skipped trade's signed base-currency notional (+ an unspent buy, − an unraised sell). */
+    tradeNotional: number;
+    reason: string;
+}
+export interface AllocationCash {
+    targetWeight: number;
+    reserve: number;
+    /** `reserve + targetWeight × netAssetValue` — the cash the plan intends to hold. */
+    targetAmount: number;
+    /**
+     * Post-trade cash minus `targetAmount`: rounding residuals + dust residuals; negative when the
+     * buys are not funded (then `feasible` is false).
+     */
+    residualAmount: number;
+    /** Post-trade cash ÷ `netAssetValue`. */
+    achievedWeight: number;
+}
+export interface AllocatePortfolioResult {
+    asOf: EpochMs;
+    baseCurrency: string;
+    netAssetValue: number;
+    /** Sorted by instrumentId. */
+    allocations: AllocationRow[];
+    cash: AllocationCash;
+    /** Sorted by instrumentId; dust and zero trades excluded. */
+    trades: AllocationTrade[];
+    /** Sorted by instrumentId. */
+    dust: AllocationDustRow[];
+    estimatedTransactionCost: number;
+    /** `Σ |trade notional| ÷ netAssetValue` (buys and sells both counted). */
+    turnover: number;
+    /** Sorted by key, then reason. */
+    unresolved: UnresolvedTarget[];
+    /** No unresolved target AND the buys are funded (cash residual ≥ 0). */
+    feasible: boolean;
+    assumptions: {
+        conventionsVersion: string;
+        targetSource: ResolvedTargetSource;
+        rounding: string;
+        costModel: string;
+        pricing: string;
+        currencyConversionsUsed: CurrencyPairQuote[];
+    };
+    diagnostics: {
+        warnings: string[];
+        instrumentCount: number;
+        tradeCount: number;
+        dustCount: number;
+        unresolvedCount: number;
+    };
+}
+/** The validated sizing grammar. `null` = not supplied (fractional quantities / no dust threshold). */
+export interface AllocationSizing {
+    lotSizes: Record<string, number>;
+    defaultLotSize: number | null;
+    minimumNotional: number | null;
+    transactionCosts: Required<AllocationTransactionCosts>;
+}
+/** Validate the lot-size / minimum-notional / cost grammar (package-internal; shared). */
+export declare function requireAllocationSizing(functionName: string, input: AllocationSizingInput): AllocationSizing;
+/** The lot size that applies to an instrument, or `null` when neither grammar covers it. */
+export declare function lotSizeFor(sizing: AllocationSizing, instrumentId: string): number | null;
+/**
+ * Round a signed quantity TOWARD ZERO to a whole number of lots (a short quantity's magnitude
+ * shrinks too). The quotient is nudged by 1e-9 lots before truncation so float noise below a whole
+ * lot never drops a lot. Never returns −0.
+ */
+export declare function roundTowardZeroToLot(quantity: number, lotSize: number | null): number;
+export interface TradeCostEstimate {
+    commission: number;
+    spread: number;
+    slippage: number;
+    total: number;
+}
+/** The cost model: commission per trade + per unit, spread and slippage in basis points of |notional|. */
+export declare function estimateTradeCost(costs: Required<AllocationTransactionCosts>, quantity: number, notionalInBaseCurrency: number): TradeCostEstimate;
+/** Prose statement of the cost model actually applied (string-typed by design). */
+export declare function describeCostModel(costs: Required<AllocationTransactionCosts>): string;
+/** Prose statement of the rounding convention actually applied (string-typed by design). */
+export declare function describeRounding(sizing: AllocationSizing, fractionalInstruments: string[]): string;
+/** Deterministic order for unresolved rows: key, then reason. */
+export declare function sortUnresolved(rows: UnresolvedTarget[]): UnresolvedTarget[];
+/**
+ * Turn a policy's target weights into executable quantities at `asOf` — see the module comment for
+ * the laws. A proposal built on this is a PLAN: nothing here executes anything.
+ *
+ * @example
+ * ```ts
+ * import { allocatePortfolio } from '@insiderfinance/totalfinance/portfolio/policy';
+ *
+ * const plan = allocatePortfolio({
+ *   policy: {
+ *     targets: [
+ *       { group: { instrumentId: 'SPY' }, weight: 0.6 },
+ *       { group: { instrumentId: 'AGG' }, weight: 0.3 },
+ *       { group: { assetClass: 'cash' }, weight: 0.1 },
+ *     ],
+ *   },
+ *   asOf: '2026-08-29',
+ *   baseCurrency: 'USD',
+ *   netAssetValue: 100_000,
+ *   prices: { SPY: { price: 150, currency: 'USD' }, AGG: { price: 100, currency: 'USD' } },
+ *   defaultLotSize: 1,
+ * });
+ * plan.trades; // buy 400 SPY, buy 300 AGG; plan.cash.residualAmount === 0
+ * ```
+ */
+export declare function allocatePortfolio(input: AllocatePortfolioInput): AllocatePortfolioResult;
+//# sourceMappingURL=allocation.d.ts.map

package/modules/portfolio/dist/allocation.d.ts.map

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