@insiderfinance/totalfinance 0.1.0

package/modules/core/dist/pricing.d.ts

@@ -0,0 +1,418 @@
+/**
+ * Gate C — the narrow structural extension contract (`@insiderfinance/totalfinance/core/pricing`).
+ *
+ * This module is the WHOLE protocol a heterogeneous position is priced through: a small structural
+ * `Pricer` interface, typed market-requirement descriptors, the engine-selection report grammar,
+ * and a behavioral conformance kit driven by caller-supplied fixtures. It contains ZERO pricing
+ * mathematics — pricers are ADAPTERS around existing public functions (the no-second-engine law),
+ * and a caller who wants one formula keeps calling the formula (the directness law).
+ *
+ * Three deliberate absences, per the platform roadmap's Gate C constraints:
+ *   - no universal instrument superclass — `Pricer<TInstrument>` is structural and generic;
+ *   - no mutable global evaluation date — the valuation instant is a market REQUIREMENT
+ *     (`{ kind: 'valuationInstant' }`) satisfied by an observation like any other input;
+ *   - no stringly typed mega-dispatch — requirements are a closed discriminated union and engine
+ *     choice is an engine OBJECT on the concrete adapter, never a name looked up in a registry.
+ *
+ * Requirement descriptors NAME snapshot observation kinds as plain data so a Gate B market
+ * snapshot can satisfy them, but this module never imports the artifacts layer — the coupling is
+ * a shared vocabulary, not a dependency (design note in the Gate C spec).
+ */
+import { type Computed } from './computed.js';
+import type { QuantWarning } from './diagnostics.js';
+import { type RateCurve } from './market-data.js';
+import { type EpochMs } from './time.js';
+/**
+ * The closed set of observation kinds a pricer may require. These names are the shared vocabulary
+ * with the Gate B market-snapshot spine: a snapshot stores observations under the SAME kinds, so a
+ * runner can satisfy a requirement by lookup without either side importing the other. The set is
+ * extended here (one union member + one row in `REQUIREMENT_SUBJECT_FIELDS` + one value type), and
+ * every extension is a reviewed vocabulary decision, not a runtime registration.
+ */
+export type ObservationKind = 'valuationInstant' | 'spot' | 'forward' | 'impliedVolatility' | 'riskFreeRate' | 'dividendYield' | 'discountCurve';
+/**
+ * The instant a valuation is "as of". Required by any pricer that discounts or measures time to
+ * expiry. Making it a requirement — rather than ambient state — is what makes "no mutable global
+ * evaluation date" structural: two books can value the same instruments at two instants
+ * concurrently, and a scenario that shifts time shifts an observation, not a process global.
+ */
+export interface ValuationInstantRequirement {
+    kind: 'valuationInstant';
+    /** `true` marks a requirement the pricer consumes when present and defaults DISCLOSED otherwise. */
+    optional?: boolean;
+}
+/** The spot price of one underlying. */
+export interface SpotRequirement {
+    kind: 'spot';
+    symbol: string;
+    optional?: boolean;
+}
+/** The forward price of one underlying to a delivery/expiry instant. */
+export interface ForwardRequirement {
+    kind: 'forward';
+    symbol: string;
+    /** Delivery/expiry instant (epoch ms) the forward settles to. */
+    expiresAt: EpochMs;
+    optional?: boolean;
+}
+/** An implied volatility (decimal, e.g. `0.24`) for one contract coordinate. */
+export interface ImpliedVolatilityRequirement {
+    kind: 'impliedVolatility';
+    symbol: string;
+    strike: number;
+    /** Expiration instant (epoch ms) of the contract the volatility belongs to. */
+    expiresAt: EpochMs;
+    optional?: boolean;
+}
+/** A continuously-compounded risk-free rate (decimal) for one currency. */
+export interface RiskFreeRateRequirement {
+    kind: 'riskFreeRate';
+    currency: string;
+    optional?: boolean;
+}
+/** A continuous dividend yield (decimal) for one underlying. */
+export interface DividendYieldRequirement {
+    kind: 'dividendYield';
+    symbol: string;
+    optional?: boolean;
+}
+/**
+ * ONE named discount curve, satisfied by a core {@link RateCurve} — PLAIN DATA, the same payload a
+ * Gate B market snapshot stores under `observations.curves`, so the observation list stays
+ * serializable and replayable end to end. Consumers (e.g. a fixed-income adapter) evaluate the
+ * curve with their own machinery; the protocol carries data, never behavior.
+ *
+ * `curveId` IS the snapshot `curves` label (e.g. `'USD.sofr'`) — that binding is the identity: a
+ * snapshot stores multiple same-currency curves under caller labels, so a currency alone cannot
+ * name one, and a runner satisfies this requirement by `snapshot.observations.curves[curveId]`.
+ * `currency` remains a subject field AND a cross-check: the satisfying curve's own declared
+ * `currency` must equal it, so a USD requirement can never be quietly satisfied by an EUR curve
+ * that happened to sit under the requested label.
+ */
+export interface DiscountCurveRequirement {
+    kind: 'discountCurve';
+    /** The snapshot `observations.curves` label naming the exact curve (e.g. `'USD.sofr'`). */
+    curveId: string;
+    currency: string;
+    optional?: boolean;
+}
+/**
+ * One typed market-requirement descriptor — plain, serializable data. A pricer returns these from
+ * `requirements(instrument)`; a runner satisfies them from a snapshot; a missing REQUIRED one is a
+ * teaching error (`pricer.requirement_unsatisfied`), never a guessed value. There is deliberately
+ * no "god market object": each pricer names exactly the observations it consumes, so a book runner
+ * can gather the union for a heterogeneous book and know it is complete.
+ */
+export type MarketRequirement = ValuationInstantRequirement | SpotRequirement | ForwardRequirement | ImpliedVolatilityRequirement | RiskFreeRateRequirement | DividendYieldRequirement | DiscountCurveRequirement;
+/** The value type each observation kind is satisfied with. Every value is plain, serializable data. */
+export interface ObservationValueByKind {
+    /**
+     * Epoch ms, `'YYYY-MM-DD'`, or a zoned ISO datetime — the workspace `asOf` grammar, validated
+     * through core's `resolveAsOf` (the same resolution the market snapshot's create path applies),
+     * so `'yesterday-ish'` and impossible calendar dates teach here, not downstream.
+     */
+    valuationInstant: EpochMs | string;
+    spot: number;
+    forward: number;
+    /** Annualized decimal, ≥ 0 — a volatility quote is a magnitude, never a signed number. */
+    impliedVolatility: number;
+    riskFreeRate: number;
+    dividendYield: number;
+    /**
+     * Core's plain-data {@link RateCurve} — the SAME payload Gate B snapshots store under
+     * `observations.curves`, validated with the shared core curve validator. Consumers evaluate it
+     * with their own machinery (a fixed-income adapter bootstraps/interpolates as its heads already
+     * do); the observation itself carries no methods, so the list serializes and replays.
+     */
+    discountCurve: RateCurve;
+}
+/** The requirement-descriptor variant for one kind. */
+export type RequirementOfKind<K extends ObservationKind> = Extract<MarketRequirement, {
+    kind: K;
+}>;
+/**
+ * One satisfied requirement: the descriptor it answers plus the value. Carrying the DESCRIPTOR
+ * (not a bare keyed map) keeps matching structural and lets the same observation list serialize,
+ * diff, and replay alongside Gate B snapshots.
+ */
+export type MarketObservation = {
+    [K in ObservationKind]: {
+        requirement: RequirementOfKind<K>;
+        value: ObservationValueByKind[K];
+    };
+}[ObservationKind];
+/**
+ * Validate one requirement descriptor: known kind, closed keys, correctly-typed subject fields.
+ * Used by the helpers below and by the conformance kit; adapters get it for free through them.
+ */
+export declare function validateMarketRequirement(functionName: string, label: string, requirement: unknown): MarketRequirement;
+/**
+ * Canonical identity of a requirement: kind plus subject fields in declaration order, e.g.
+ * `impliedVolatility(symbol=AAPL, strike=200, expiresAt=1789430400000)` or
+ * `discountCurve(curveId=USD.sofr, currency=USD)`. The `optional` marker is NOT part of identity —
+ * an optional and a required descriptor for the same coordinate match the same observation. This
+ * string is how runners match, deduplicate across a book, and how missing requirements are NAMED
+ * in teaching errors.
+ */
+export declare function requirementKey(requirement: MarketRequirement): string;
+/** Whether two descriptors identify the same observation (same kind + subject; `optional` ignored). */
+export declare function sameRequirement(first: MarketRequirement, second: MarketRequirement): boolean;
+/** Validate one observation: a valid descriptor plus a value of that kind's type. */
+export declare function validateMarketObservation(functionName: string, label: string, observation: unknown): MarketObservation;
+/** Find the observation satisfying `requirement`, or `undefined`. Pure lookup, no validation walk. */
+export declare function observationFor(observations: readonly MarketObservation[], requirement: MarketRequirement): MarketObservation | undefined;
+/**
+ * The value satisfying a REQUIRED requirement. Missing → the protocol's teaching error
+ * (`pricer.requirement_unsatisfied`, naming the exact descriptor and what was received) — the one
+ * error code the conformance kit demands, so adapters built on this helper conform by construction.
+ */
+export declare function requireObservationValue<K extends ObservationKind>(functionName: string, observations: readonly MarketObservation[], requirement: MarketRequirement & {
+    kind: K;
+}): ObservationValueByKind[K];
+/**
+ * The value satisfying an OPTIONAL requirement, or `undefined` when absent. The consuming pricer
+ * owns disclosing whatever default it applies (the no-silent-economics law); this helper only
+ * makes "absent" unambiguous.
+ */
+export declare function optionalObservationValue<K extends ObservationKind>(functionName: string, observations: readonly MarketObservation[], requirement: MarketRequirement & {
+    kind: K;
+}): ObservationValueByKind[K] | undefined;
+/**
+ * The REQUIRED requirements not satisfied by `observations` — a runner's pre-flight, so a book can
+ * report every gap at once instead of failing one missing observation at a time. Optional
+ * requirements never appear here.
+ */
+export declare function missingRequirements(input: {
+    requirements: readonly MarketRequirement[];
+    observations: readonly MarketObservation[];
+}): readonly MarketRequirement[];
+/** One engine an automatic selection considered, with why it was or was not usable/chosen. */
+export interface SelectionCandidate {
+    /** Engine name exactly as `diagnostics.engine` would report it. */
+    name: string;
+    /** Whether the candidate could have priced this request at all. */
+    eligible: boolean;
+    /** One sentence: why it was chosen, passed over, or ineligible. */
+    reason: string;
+}
+/**
+ * The inspectable engine-selection report carried at `diagnostics.selection`. This FORMALIZES the
+ * options package's existing `diagnostics.engine` + `diagnostics.autoReason` disclosure — one
+ * grammar, not a parallel scheme: `selected.name` always agrees with `diagnostics.engine`, and for
+ * automatic mode `reason` is the same sentence `autoReason` carries.
+ *
+ *   - `mode: 'explicit'` — the caller named the engine; nothing was considered, so `candidates`
+ *     is ABSENT (an empty considered-list would fabricate deliberation that never happened).
+ *   - `mode: 'automatic'` — the pricer chose, and must show its work: `candidates` lists every
+ *     engine the routing considered, each with an eligibility verdict and a reason, and the
+ *     selected engine appears among them as an eligible row.
+ */
+export interface SelectionReport {
+    mode: 'explicit' | 'automatic';
+    selected: {
+        name: string;
+        version?: string;
+    };
+    /** Why the selected engine answers this request. */
+    reason: string;
+    /** Candidates an automatic selection considered; absent for explicit mode. */
+    candidates?: readonly SelectionCandidate[];
+}
+/** Validate a selection report's grammar (shape, mode/candidates coherence, chosen-among-candidates). */
+export declare function validateSelectionReport(functionName: string, report: unknown): SelectionReport;
+/**
+ * Machine-readable pricer capabilities, behaviorally verified by {@link validatePricer} — a claim
+ * the kit cannot confirm fails conformance, so capabilities can never drift into marketing (the
+ * same discipline as the options package's `EngineCapabilities`).
+ *
+ * Deliberately NOT here: `price` (a Pricer that cannot price is not a Pricer — it is the one
+ * mandatory method) and `scenarios` (revaluing under shocked observations is what `price` over
+ * requirement-satisfied observations MEANS; every conformant pricer supports scenarios
+ * structurally, so a flag would be noise).
+ */
+export interface PricerCapabilities {
+    /**
+     * How Greeks are produced when `request.greeks` is set: closed-form (`analytic`), bump-and-
+     * reprice (`finite-difference`), by whatever engine was selected (`delegated`), or not at all
+     * (`none` — the request is not honored and no `greeks` field appears; never fabricated zeros).
+     */
+    readonly greeks: 'analytic' | 'finite-difference' | 'delegated' | 'none';
+    /**
+     * Where the pricer's randomness lives — behaviorally verified, replacing the earlier
+     * `deterministic: boolean` (pre-1.0 rename, 2026-08-23, second external review):
+     *
+     *   - `'none'` — same instrument + observations + request → byte-identical COMPLETE results,
+     *     and a supplied `request.seed` is IGNORED entirely (verified: identical results with and
+     *     without one).
+     *   - `'seeded'` — the pricer consumes randomness, but ONLY through the caller's
+     *     `request.seed`: the seed is REQUIRED (its absence is a typed `input.missing_field`
+     *     refusal naming `request.seed`), it is echoed at `assumptions.seed`, and two same-seed
+     *     calls return byte-identical COMPLETE results. Batches obey the derivation law documented
+     *     on {@link PricerValuationRequest.seed}: item `i` prices under `seed + i`.
+     *
+     * There is deliberately NO free-running mode: a pricer whose results the kit cannot reproduce
+     * under a fixed seed makes claims the kit cannot verify, and a claim the kit cannot verify is
+     * marketing. Free-running randomness is non-conformant.
+     */
+    readonly randomness: 'none' | 'seeded';
+    /** Whether `priceBatch` exists (one observation set, many instruments — the book fast path). */
+    readonly batch: boolean;
+}
+/** Per-call request flags. Closed; adapters map them onto their wrapped function's own options. */
+export interface PricerValuationRequest {
+    /** Compute Greeks when the pricer's capability allows (adapter default follows the wrapped API). */
+    greeks?: boolean;
+    /**
+     * Randomness seed — a non-negative safe integer when present. REQUIRED by
+     * `randomness: 'seeded'` pricers (a call without it is a typed `input.missing_field` refusal
+     * naming this field) and echoed at `assumptions.seed`, so every stochastic result names what
+     * reproduces it; IGNORED entirely by `randomness: 'none'` pricers (complete results with and
+     * without a seed are identical — verified). THE BATCH DERIVATION LAW (stated here so
+     * implementors can comply, verified by {@link validatePricer}):
+     * `priceBatch({ instruments, observations, request })` item `i` must deep-equal
+     * `price(instruments[i], observations, { ...request, seed: request.seed + i })` — one
+     * documented, stable derivation, so a batch replays item-by-item through the scalar path. A
+     * seeded batch whose `seed + instruments.length - 1` would exceed `Number.MAX_SAFE_INTEGER`
+     * is refused rather than letting derived seeds silently collide.
+     */
+    seed?: number;
+}
+/** One complete scalar pricing request. */
+export interface PricerPriceInput<TInstrument> {
+    instrument: TInstrument;
+    /** Observations satisfying the pricer's declared requirements for this instrument. */
+    observations: readonly MarketObservation[];
+    request?: PricerValuationRequest;
+}
+/** One complete batch pricing request: one coherent observation set across many instruments. */
+export interface PricerBatchPriceInput<TInstrument> {
+    instruments: readonly TInstrument[];
+    observations: readonly MarketObservation[];
+    request?: PricerValuationRequest;
+}
+/**
+ * The minimal structural protocol a heterogeneous position is priced through (Gate C).
+ *
+ * Small on purpose: identity (`name`/`version`), verified `capabilities`, a `supports` gate, a
+ * `requirements` declaration, and `price` returning the workspace's EXISTING result envelope
+ * (the structural {@link PricerValuationResult} floor — Law 2's grammar, never a new envelope;
+ * domain pricers preserve their richer result, e.g. options `PriceResult` or a bond result with
+ * fixed-income-specific assumptions). That is enough
+ * for Gate D's book to run one scenario across mixed instruments: gather the union of
+ * requirements, satisfy them from one snapshot, shock observations, and call `price` per position
+ * — while every direct function underneath stays independently callable.
+ *
+ * Implementations are ADAPTERS around existing public functions. If writing a Pricer requires
+ * writing pricing math that does not already exist as a direct public function, the math lands as
+ * a direct function first (the no-second-engine law).
+ */
+/**
+ * Domain-neutral static floor for a Gate-C valuation result.
+ *
+ * `Computed<number>` is the default, but domains may legitimately widen assumption vocabularies
+ * (fixed income uses `compounding: 'curve'`). Gate C consumes only this structural Law-2 floor and
+ * preserves every extra field, matching the existing `isComputed` runtime law.
+ */
+export interface PricerValuationResult {
+    readonly value: number;
+    readonly assumptions: {
+        readonly conventionsVersion: string;
+    };
+    readonly diagnostics: {
+        readonly warnings: readonly QuantWarning[];
+        readonly engine?: string;
+        readonly selection?: SelectionReport;
+    };
+}
+export interface Pricer<TInstrument, TValuation extends PricerValuationResult = Computed<number>> {
+    /** Stable identity, reported in diagnostics and selection reports. */
+    readonly name: string;
+    readonly version: string;
+    /** Verified by {@link validatePricer}; never self-certified marketing. */
+    readonly capabilities: PricerCapabilities;
+    /** Whether this pricer can price the instrument. Runners gate on this before `requirements`. */
+    supports(instrument: TInstrument): boolean;
+    /**
+     * The typed market requirements pricing THIS instrument consumes — required ones missing at
+     * `price` time must throw `pricer.requirement_unsatisfied`; observations outside this list must
+     * not influence the result (both are conformance-probed).
+     */
+    requirements(instrument: TInstrument): readonly MarketRequirement[];
+    price(input: PricerPriceInput<TInstrument>): TValuation;
+    /** Present iff `capabilities.batch`; must agree with `price` result-for-result. */
+    priceBatch?(input: PricerBatchPriceInput<TInstrument>): readonly TValuation[];
+}
+/**
+ * Structural, side-effect-free validation of a pricer definition (identity, capability grammar,
+ * method presence, batch coherence). Mirrors `defineOptionPricingEngine`: definition stays cheap
+ * and fixture-free; behavioral proof is the explicit opt-in ({@link validatePricer}), because the
+ * protocol cannot invent a valid instrument or market for an arbitrary domain. Returns a frozen
+ * pricer with bound methods.
+ */
+export declare function definePricer<TInstrument, TValuation extends PricerValuationResult = Computed<number>>(pricer: Pricer<TInstrument, TValuation>): Pricer<TInstrument, TValuation>;
+/**
+ * One caller-supplied behavioral fixture for {@link validatePricer}. The CALLER supplies the
+ * instrument and a full observation set — the kit cannot invent meaningful market data for an
+ * arbitrary domain (the same reasoning as `validateOptionPricingEngine`).
+ */
+export interface PricerProbe<TInstrument> {
+    /** An instrument the pricer claims to support. */
+    instrument: TInstrument;
+    /**
+     * Observations satisfying every REQUIRED declared requirement (optional ones too, when the
+     * probe should exercise them). Extra observations beyond the declaration are allowed — the kit
+     * uses them to prove the pricer does not read what it does not declare.
+     */
+    observations: readonly MarketObservation[];
+    request?: PricerValuationRequest;
+    /**
+     * Assert that this probe's result carries a selection report of the given mode. Selection
+     * disclosure is per-pricer (a single-model pricer has nothing to select), so the CALLER states
+     * the expectation where one exists; the kit always validates a present report's grammar.
+     */
+    expectSelection?: 'explicit' | 'automatic';
+}
+/**
+ * Behaviorally verify a Pricer against CALLER-SUPPLIED fixtures. Every failure teaches: the error
+ * names the probe, the broken law, and the fix.
+ *
+ * Per probe, the kit proves:
+ *   1. `supports(instrument)` returns `true` (a probe instrument the pricer rejects is a fixture
+ *      error, reported as such);
+ *   2. `requirements(instrument)` returns valid, duplicate-free descriptors and is STABLE across
+ *      calls — a runner must be able to gather once and price after;
+ *   3. pricing with exactly the declared observations succeeds and returns the Law-2 envelope
+ *      (`value`/`assumptions`/`diagnostics`) with a fully finite success (Law 7, via the same
+ *      walker the library uses);
+ *   4. requirement honesty, both directions: each REQUIRED observation removed one at a time makes
+ *      `price` throw `pricer.requirement_unsatisfied` naming the requirement (never a silent
+ *      guess); each OPTIONAL observation removed still succeeds; and undeclared observations
+ *      (the probe's extras plus an injected foreign one) leave the COMPLETE result identical —
+ *      compared as canonical JSON over the whole envelope (value, greeks, assumptions,
+ *      diagnostics), so a pricer cannot consume what it does not declare and hide the read in a
+ *      field the probe forgot to look at;
+ *   5. capability honesty (randomness — 2026-08-23, second external review; every comparison is
+ *      the COMPLETE canonical result, never `.value` alone): for `randomness: 'none'`, a repeat
+ *      call is byte-identical AND a supplied `request.seed` changes nothing (the seed-ignoring
+ *      law); for `randomness: 'seeded'`, every law is proved under a fixed seed (the probe's
+ *      `request.seed`, else {@link CONFORMANCE_PROBE_SEED}): a call WITHOUT a seed is a typed
+ *      `input.missing_field` refusal naming `request.seed`, the seed is echoed at
+ *      `assumptions.seed`, two same-seed calls are byte-identical, undeclared-observation
+ *      independence holds under that seed, and `priceBatch` obeys the documented derivation law —
+ *      item `i` deep-equals the scalar result under `seed + i` (a two-copy batch is probed so the
+ *      derivation is actually exercised; a probe seed leaving no safe-integer room for `seed + i`
+ *      is refused, typed). `greeks` mode → a NON-EMPTY greeks object with finite-or-null leaves
+ *      exactly when claimed (`{}` measures nothing and fails); `batch` → `priceBatch` exists and
+ *      agrees with `price` COMPLETE-result-for-result on the probe — and (2026-08-23, fourth
+ *      external review) EVERY seed law proved against `price()` is proved against `priceBatch()`
+ *      too, on an at-least-two-instrument batch: a `'seeded'` batch without `request.seed` must
+ *      refuse exactly as the scalar path does (a silently defaulted seed is unreproducible), a
+ *      `'none'` batch must ignore a supplied seed item-for-item, and undeclared-observation
+ *      independence must hold on the batch path in both modes;
+ *   6. selection honesty: any `diagnostics.selection` present validates against the report grammar
+ *      and agrees with `diagnostics.engine`; `expectSelection` makes the report mandatory.
+ *
+ * Returns the validated (frozen, bound) pricer for inline use.
+ */
+export declare function validatePricer<TInstrument, TValuation extends PricerValuationResult = Computed<number>>(pricer: Pricer<TInstrument, TValuation>, probes: readonly PricerProbe<TInstrument>[]): Pricer<TInstrument, TValuation>;
+//# sourceMappingURL=pricing.d.ts.map

package/modules/core/dist/pricing.d.ts.map

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