@1delta/margin-fetcher 0.0.411 → 0.0.413

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { PublicClient, Address, Hex } from 'viem';
 import { Lender } from '@1delta/lender-registry';
-export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
+export { hasCrossMarginRisk, isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
 import { DebitData, LenderDebitData, LstAcceptedInput } from '@1delta/calldata-sdk';
 import { RelayProxyConfig } from '@1delta/proxy-fetch';
-import { TermMarketConfig, LiquityBranchConfig, LiquityConfigChain, RiverMarketConfig, RiverConfigChain, RiverChainData, InverseMarketConfig, InverseConfigChain, InverseChainData, UsddMarketConfig, UsddConfigChain, UsddChainData, TellerPoolConfig, MorphoTypeVaultEntry } from '@1delta/data-sdk';
+import { TermMarketConfig, LiquityBranchConfig, LiquityConfigChain, RiverMarketConfig, RiverConfigChain, RiverChainData, InverseMarketConfig, InverseConfigChain, InverseChainData, ResupplyConfigChain, LlamaLendMarketConfig, LlamaLendConfigChain, LlamaLendChainData, UsddMarketConfig, UsddConfigChain, UsddChainData, FrankencoinMarketConfig, FrankencoinConfigChain, FrankencoinChainData, TellerPoolConfig, MorphoTypeVaultEntry } from '@1delta/data-sdk';
 export { MorphoLensAbi } from '@1delta/abis';
 
 interface GenericCurrency {
@@ -787,6 +787,38 @@ declare function createRawRpcCalls(preparedCalls: PreparedCall[], batchSize?: nu
 declare function createMulticallRpcCall(preparedCalls: PreparedCall[], multicallAddress: string, batchSize?: number, blockTag?: string, allowFailure?: boolean): MulticallRpcBatch[];
 
 type Call = GeneralCall;
+/**
+ * Sentinel written into the result array for a call that returned NO data —
+ * a revert, an RPC error, or a whole `aggregate3` chunk that was rejected
+ * (rate limit, subrequest cap, dropped connection: viem marks every call in a
+ * rejected chunk as `status: 'failure'`).
+ *
+ * It is NOT a zero value. Parsers must skip these slots — coercing one to `0`
+ * turns a failed read into a phantom "no balance" position and, worse, makes a
+ * real deposit or debt silently disappear from a user's portfolio.
+ */
+declare const MULTICALL_FAILURE = "0x";
+/** True when a multicall slot holds no usable data (see {@link MULTICALL_FAILURE}). */
+declare const isFailedCall: (value: unknown) => boolean;
+/** Reported for each endpoint that failed to serve a batch. */
+interface EndpointFailure {
+    chainId: string;
+    /** Endpoint URL, or `rpc#<id>` when the transport does not expose one. */
+    url: string;
+    rpcId: number;
+    /** `transport` — the request itself died. `slots` — it answered with nothing but failures. */
+    kind: 'transport' | 'slots';
+}
+interface MulticallEndpointOptions {
+    /**
+     * Endpoint URLs already attempted for this call set. Failover consults it so
+     * a retry lands on an endpoint that has NOT already failed — see
+     * {@link resolveEndpoint}.
+     */
+    tried?: Set<string>;
+    /** Invoked for every endpoint that fails, so callers can demote it. */
+    onEndpointFailure?: (info: EndpointFailure) => void;
+}
 declare function prepareMulticallInputs(abi: any[], calls: Call[]): PreparedCall[];
 
 interface PreparedUserDataRpcCalls {
@@ -1049,33 +1081,106 @@ type UserData = {
      * not as the user's full position.
      */
     incomplete?: boolean;
+    /**
+     * Set when this entry did NOT come from the current read: the live read failed
+     * and a previously COMPLETE snapshot was served in its place. The position was
+     * accurate as of `staleAgeMs` ago; it is not a partial read (those are
+     * `incomplete`) and it is never served for a lender that read successfully.
+     */
+    stale?: boolean;
+    /** Age of the served snapshot in ms. Only set alongside `stale`. */
+    staleAgeMs?: number;
 };
 
-/** Reported per lender whose multicall slice contained failed reads. */
+/**
+ * How a lender's slice reacts to a failed read.
+ *
+ * Note what this is NOT keyed on: "is the position cross-margin". EVERY position
+ * with debt is corrupted by a lost read — an isolated Morpho market computes its
+ * health from a collateral read and a debt read, so losing either fabricates the
+ * same nonsense a lost Aave reserve does. The question here is narrower and
+ * purely mechanical: **what is the smallest thing we can void?** A failed slot
+ * carries no market label, so the only unit we can void is the lender key.
+ *
+ * - `strict` — void the whole slice on any lost read. Correct when the slice
+ *   resolves to ONE risk computation, which is true both for a single-market
+ *   lender and for a multi-market lender that is nevertheless cross-margin
+ *   (Exactly scores every market under one per-chain Auditor). Nothing smaller
+ *   can be voided, and publishing the remainder would publish a fiction.
+ * - `lenient` — publish, flag `incomplete`, and let per-record invariant
+ *   validation catch the corrupted one. Correct ONLY when the slice fans out to
+ *   many INDEPENDENT isolated positions, where voiding the key would discard
+ *   hundreds of intact markets to hide one — a cure worse than the disease.
+ *
+ * So leniency requires BOTH properties: many independent positions AND no shared
+ * risk computation across them.
+ */
+type ReadFailurePolicy = 'strict' | 'lenient';
+declare const getReadFailurePolicy: (lender: string) => ReadFailurePolicy;
+/** Why a lender's slice did not convert cleanly. */
+type IncompleteReason = 
+/** Every read in the slice failed. */
+'all-reads-failed'
+/** Reads failed on a strict lender — the whole risk set was voided. */
+ | 'partial-read-cross-margin'
+/** Reads failed on a lenient lender — surviving markets were published. */
+ | 'partial-read'
+/** The converter threw. */
+ | 'converter-error'
+/** The converted entry asserted something that cannot be true. */
+ | 'invariant-violation';
+/** Reported per lender whose multicall slice did not convert cleanly. */
 interface IncompleteLenderRead {
     lender: string;
     /** Number of slots in the lender's slice that returned no data. */
     failedCalls: number;
+    /**
+     * Subset of `failedCalls` that could plausibly succeed on a re-read — i.e.
+     * excluding calls known to have reverted. Zero means re-fetching this lender
+     * is pointless: the markets in question always revert for this account.
+     * Equals `failedCalls` when no `permanentFailures` set was supplied.
+     */
+    retryableFailedCalls: number;
     /** Size of the lender's slice. */
     totalCalls: number;
-    /** True when EVERY read failed and the lender was skipped entirely. */
+    /** True when nothing was published for this lender. */
     dropped: boolean;
+    /** What went wrong. */
+    reason: IncompleteReason;
+    /** Extra context for logs (converter message, violation details). */
+    detail?: string;
 }
 interface ConvertLenderUserDataOptions {
-    /** Invoked once per lender with failed reads — for logging / surfacing. */
+    /** Invoked once per lender that did not convert cleanly — for logging / surfacing. */
     onIncomplete?: (info: IncompleteLenderRead) => void;
+    /**
+     * Indices (into `rawResults`) of calls that failed deterministically, as
+     * collected by `getLenderUserDataResult`. Used only to compute
+     * `retryableFailedCalls`.
+     */
+    permanentFailures?: Set<number>;
 }
 /**
  * Converts the raw results into the desired format
  *
  * Slots that hold the multicall failure sentinel are NOT data: a failed read
- * says nothing about the user's position. When every read for a lender failed
- * the lender is skipped outright — converting would emit an all-zero entry that
- * is indistinguishable from "user has no position here", which is how a
- * rate-limited RPC ends up rendering phantom $0 rows (and, when only some calls
- * fail, understated balances). Partial failures still convert — the readable
- * positions are real — but are flagged `incomplete` and reported via
- * `options.onIncomplete`.
+ * says nothing about the user's position. Coercing one to zero is how a
+ * rate-limited RPC ends up rendering phantom $0 rows and understated balances,
+ * so failures are handled explicitly, in three gates:
+ *
+ *  1. **Failure policy** (see {@link ReadFailurePolicy}). Every read failing
+ *     drops the lender under either policy. Beyond that, a `strict`
+ *     (cross-margin) lender drops on ANY failure because its aggregates are only
+ *     meaningful over the complete set, while a `lenient` (multi-market) lender
+ *     publishes the markets that did read and is flagged `incomplete`.
+ *  2. **Converter errors** are reported rather than swallowed — a throwing
+ *     converter used to leave a lender silently absent, indistinguishable from a
+ *     user with no position there.
+ *  3. **Invariant validation** (see `validate.ts`) rejects sub-accounts that
+ *     cannot be true regardless of how the reads went — a `NaN` anywhere in the
+ *     aggregates, or (alongside failed reads) debt with no collateral behind it.
+ *
+ * Anything published after that is either complete or explicitly marked as not.
  *
  * @param chainId - The chain ID
  * @param queriesRaw - The queries to fetch data for
@@ -1088,6 +1193,53 @@ declare const convertLenderUserDataResult: (chainId: string, queriesRaw: LenderU
     [lender: string]: UserData;
 };
 
+/**
+ * Why this exists SEPARATELY from the failure sentinels
+ * -----------------------------------------------------
+ * The sentinel path (`isFailedCall`) catches reads that announced themselves as
+ * failures. This catches the ones that did not: a decodable-but-wrong response,
+ * a market whose metadata went missing so its price resolved to `undefined`, a
+ * converter that divided by a zero it should never have seen. Those produce the
+ * SAME user-visible artefact as a dropped read — a debt with no collateral, a
+ * `NaN` health factor — while every slot reports success.
+ *
+ * So this is the last gate before a position is published: it asserts what must
+ * be true of any real lending position, independent of how the data was
+ * obtained.
+ */
+/** One failed assertion about a sub-account's published shape. */
+interface InvariantViolation {
+    /** Sub-account this fired on (`accountId`). */
+    accountId: string;
+    /** Machine-readable check name. */
+    code: 'non-finite' | 'debt-without-collateral' | 'invalid-mode';
+    /** Human-readable detail for logs. */
+    detail: string;
+    /**
+     * `true` when the violation is only conclusive because the read was also
+     * known-incomplete (see {@link validateUserData}).
+     */
+    requiresFailedReads: boolean;
+}
+interface ValidationResult {
+    /** Sub-accounts that passed. Empty means the whole entry must be dropped. */
+    kept: UserDataForSubAccount[];
+    /** Every violation found, including ones on kept sub-accounts. */
+    violations: InvariantViolation[];
+    /** Sub-account ids dropped as corrupt. */
+    dropped: string[];
+}
+/**
+ * Validates a converted entry and drops the sub-accounts that cannot be true.
+ *
+ * `hadFailedReads` gates the checks whose violation is ambiguous on its own:
+ * with a known-incomplete read, `debt-without-collateral` is the signature of a
+ * dropped collateral slot and the sub-account is corrupt; with a clean read it
+ * is a genuine (if grim) position and is kept. Unconditional checks — anything
+ * non-finite — fire either way, because no read produces those legitimately.
+ */
+declare function validateUserData(userData: UserData, hadFailedReads: boolean): ValidationResult;
+
 interface ExposureInfo {
     asset: GenericCurrency;
     collateralFactor: number;
@@ -1127,9 +1279,17 @@ declare function unflattenLenderData(pools: PoolWithMeta[]): LenderData;
  * @param logs - show multicall error logs, default is false
  * @param concurrency - number of distinct RPC endpoints to shard batches
  *   across in parallel; <= 1 keeps the legacy single-endpoint path
+ * @param permanentFailures - optional collector filled with the indices of
+ *   calls that failed DETERMINISTICALLY (revert / no code / unknown selector)
+ *   rather than because of the RPC. Pass it to
+ *   {@link convertLenderUserDataResult} so a caller can tell "this market
+ *   always reverts" from "this read was lost" and only re-fetch the latter.
+ * @param onEndpointFailure - optional hook invoked for every RPC endpoint that
+ *   fails to serve a batch. Only the caller knows where to persist that (KV,
+ *   metrics), and without it every request rediscovers the same bad endpoint.
  * @returns The raw results from the multicall, "0x" for failures
  */
-declare const getLenderUserDataResult: (chainId: string, queriesRaw: LenderUserQuery[], getEvmClient: GetEvmClientFunction, allowFailure?: boolean, batchSize?: number, retries?: number, logs?: boolean, concurrency?: number) => Promise<any[]>;
+declare const getLenderUserDataResult: (chainId: string, queriesRaw: LenderUserQuery[], getEvmClient: GetEvmClientFunction, allowFailure?: boolean, batchSize?: number, retries?: number, logs?: boolean, concurrency?: number, permanentFailures?: Set<number>, onEndpointFailure?: (info: EndpointFailure) => void) => Promise<any[]>;
 /**
  * Prepares the RPC calls for fetching user data without executing them
  * Uses multicall3 aggregate3 to batch all calls into a single RPC call
@@ -1484,6 +1644,21 @@ interface LenderDataEntry extends Omit<LenderSummary, 'subAccounts'> {
     account: string;
     lenderInfo?: LenderInfo;
     data: UserDataForSubAccount[];
+    /**
+     * Set when some of this lender's on-chain reads could not be completed. The
+     * positions listed are real but the set is a LOWER BOUND — anything derived
+     * from the whole picture (NAV, net APR, health factor) is unreliable and must
+     * not be rendered as fact.
+     */
+    incomplete?: boolean;
+    /**
+     * Set when this entry was served from the last COMPLETE snapshot because the
+     * live read failed. Internally consistent — unlike `incomplete` — but as of
+     * `staleAgeMs` ago rather than now.
+     */
+    stale?: boolean;
+    /** Age of the served snapshot in ms. Only set alongside `stale`. */
+    staleAgeMs?: number;
 }
 /**
  * Input type for buildSummaries - user data result from convertLenderUserDataResult
@@ -2957,6 +3132,14 @@ interface InverseMarketRaw {
     borrowPaused: boolean | null;
     /** Borrows already taken today against `dailyLimit` — API only. */
     dailyBorrows: number | null;
+    /**
+     * `Market.replenishmentIncentiveBps` (1000 = 10%) — the replenisher
+     * bot's cut of a force-replenish, per market. It is carved OUT of the
+     * `replenishmentPriceBps` cost and paid in DOLA from the market's own
+     * liquidity; the borrower's debt grows by the FULL cost either way, so
+     * this is a protocol/bot split, not an extra borrower charge.
+     */
+    replenishmentIncentiveBps: number | null;
 }
 /** Raw public-data batch for the FiRM deployment (one chain). */
 interface InverseMarketsRaw {
@@ -3020,6 +3203,184 @@ declare function convertInverseMarketsToResponse(raw: InverseMarketsRaw, chainId
     [m: string]: MorphoGeneralPublicResponse;
 };
 
+/**
+ * The immutable half of a Resupply pair. Cached across refreshes because none
+ * of it can change: `collateral` and `underlying` are set in the pair's
+ * constructor and there is no setter (`setConvexPool` only moves where the
+ * SHARES are staked, never what the collateral token is).
+ */
+interface ResupplyPairIdentity {
+    pair: string;
+    /** e.g. `Resupply Pair (CurveLend: crvUSD/sfrxUSD) - 1`. */
+    name: string;
+    /** The ERC-4626 share of the WRAPPED market — the accounting unit. */
+    collateral: string;
+    /** What the user actually deposits and withdraws: crvUSD or frxUSD. */
+    underlying: string;
+    collateralDecimals: number;
+    underlyingDecimals: number;
+}
+/**
+ * One Resupply pair after the state batch. Raw bigints; `null` = failed
+ * allowFailure read.
+ */
+interface ResupplyPairRaw {
+    identity: ResupplyPairIdentity;
+    /** 1e5-scaled (95000 = 95%). */
+    maxLTV: bigint | null;
+    /** Debt ceiling. ZERO ⇒ paused/retired — this is the liveness signal. */
+    borrowLimit: bigint | null;
+    /** 1e5-scaled penalty on top of the debt at liquidation. */
+    liquidationFee: bigint | null;
+    /** 1e5-scaled fee added to minted debt (0 on every live pair). */
+    mintFee: bigint | null;
+    /** Hard per-position floor (1,000 reUSD). */
+    minimumBorrowAmount: bigint | null;
+    /** Face reUSD debt, interest previewed. */
+    totalBorrowAmount: bigint | null;
+    totalBorrowShares: bigint | null;
+    /** Collateral SHARES held by the pair. */
+    totalCollateral: bigint | null;
+    /** 1e18-scaled per SECOND, from `currentRateInfo` (last checkpoint). */
+    ratePerSec: bigint | null;
+    /** Same, but recomputed live by the Utilities lens — preferred. */
+    liveRatePerSec: bigint | null;
+    /** The WRAPPED market's supply rate per second, 1e18-scaled. */
+    underlyingSupplyRatePerSec: bigint | null;
+    /** `convertToAssets(1e18)` on the collateral vault — UNDERLYING per share.
+     *  ~1e15 for Curve Lend vaults, ~1e18 for Fraxlend pairs. */
+    collateralPrice: bigint | null;
+    /** Cached `1e36 / collateralPrice` from the pair (stale between writes). */
+    exchangeRate: bigint | null;
+}
+interface ResupplyMarketsRaw {
+    lender: string;
+    config?: ResupplyConfigChain;
+    pairs: ResupplyPairRaw[];
+}
+
+/**
+ * Fetch every Resupply market on a chain — FULLY ON-CHAIN, no API and no
+ * published market roster.
+ *
+ * Discovery is `ResupplyRegistry.getAllPairAddresses()`. That is deliberate:
+ * governance adds pairs (7 appeared between the docs' published list and
+ * 2026-08) and retires them by zeroing `borrowLimit`, so a static file would
+ * both miss new markets and advertise frozen ones as borrowable. The registry
+ * is permissionless to read and is the same source the protocol's own
+ * periphery uses.
+ *
+ * Three rounds cold, two warm:
+ *   1. registry → pair addresses (intersected with `pairAllowlist` if set);
+ *   2. identity (`name`/`collateral`/`underlying` + both tokens' decimals) for
+ *      pairs not already cached — immutable, so this is once per pair ever;
+ *   3. state: terms, accounting, rates and the collateral vault's share price.
+ *
+ * The rate is read from the `Utilities` lens rather than `currentRateInfo`,
+ * which is only a checkpoint from the last write — on a quiet pair that can be
+ * hours stale, and the off-peg amplifier moves with the reUSD price. The
+ * checkpoint is kept as a fallback.
+ */
+declare function fetchResupplyMarkets(lender: string, chainId: string): Promise<ResupplyMarketsRaw>;
+
+/**
+ * The external lending market a Resupply pair wraps.
+ *
+ * Every Resupply pair's collateral IS another lender's supply position, so a
+ * position here carries that market's risk on top of Resupply's own. This
+ * resolves the link where we can: the collateral vault is matched against the
+ * LlamaLend roster by ADDRESS (LlamaLend indexes markets by Controller, so the
+ * lookup goes through `llamaLendMarketByVault`).
+ *
+ * Verified 2026-08-04: 16 of the 21 registered pairs match a LlamaLend market
+ * exactly, and the generation agrees independently — Resupply's own
+ * `CurveLend:` names map to LlamaLend `version: 1` and `CurveLendV2:` to
+ * `version: 2`. The other 5 are Fraxlend pairs, which we do not integrate as a
+ * lender, so they resolve to `provider: 'fraxlend'` with no market key.
+ */
+interface ResupplyWrappedMarket {
+    /** Which protocol the collateral position lives in. */
+    provider: 'llamalend' | 'fraxlend' | 'unknown';
+    /** The ERC-4626 the pair custodies — always known (it IS the collateral). */
+    vault: string;
+    /** `LLAMALEND_<CONTROLLER_ADDR>` when we integrate that market, else absent.
+     *  This is the key to look the wrapped market up in our own data. */
+    lender?: string;
+    /** LlamaLend Controller (the borrow surface of the wrapped market). */
+    controller?: string;
+    /** LlamaLend LLAMMA. Carried because a leverage route through Resupply must
+     *  never touch it — the wrapped Controller asserts its band state. */
+    amm?: string;
+    /** 1 = `oneway`, 2 = `oneway-v2`. Matches Resupply's CurveLend/CurveLendV2. */
+    version?: 1 | 2;
+    /** What the wrapped market lends against, e.g. `sfrxUSD`. */
+    collateralSymbol?: string;
+}
+/**
+ * Synthesized per-pair lender key, e.g. `RESUPPLY_1_C5184CCC…`. The chain id
+ * rides in the key (Fluid/River/Frankencoin convention) even though Resupply
+ * is Ethereum-only today.
+ */
+declare function resupplyLenderKey(lender: string, chainId: string | number, pair: string): string;
+/** Recover `{ lender, chainId, pair }` from a per-pair key. */
+declare function resupplyKeyParts(key: string): {
+    lender: string;
+    chainId: string;
+    pair: string;
+} | undefined;
+/**
+ * Map one Resupply deployment's on-chain batch into the shared
+ * `MorphoGeneralPublicResponse` shape, keyed `RESUPPLY_<chainId>_<PAIR>`.
+ *
+ * Four modelling decisions worth knowing (all from RESUPPLY_PLAN.md):
+ *
+ *  - **The collateral we publish is the UNDERLYING (crvUSD / frxUSD), not the
+ *    ERC-4626 share.** The share is an internal accounting unit that no token
+ *    list carries and no price feed covers, and both user-facing entry points
+ *    (`addCollateral` / `removeCollateral`) are denominated in the underlying.
+ *    Share amounts are converted with the vault's own
+ *    `convertToAssets(1e18)` — the exact number Resupply's oracle uses. NB
+ *    that price is ~**1e15** for Curve Lend vaults, so the share count is
+ *    ~1000x the underlying; a bare 1e18 divide is wrong by three orders of
+ *    magnitude.
+ *  - **The collateral carries the wrapped market's yield.** A Resupply deposit
+ *    is a Curve Lend / Fraxlend supply position, so `getUnderlyingSupplyRate`
+ *    is published as the collateral row's `intrinsicYield`. Without it the
+ *    position looks like it pays nothing, when in fact the whole product is
+ *    the spread between that and the ~half-of-it borrow rate.
+ *  - **`borrowLimit == 0` means PAUSED.** `pause()` zeroes it and there is no
+ *    `isPaused`; 9 of 21 pairs sat at zero at integration. Such a pair is
+ *    reported frozen and non-borrowable, but deposits/withdrawals stay open so
+ *    users can exit.
+ *  - **There is no supply side** — reUSD is minted — so `totalDeposits` on the
+ *    loan row is 0 and `depositRate` is 0. The earn leg is sreUSD, which
+ *    belongs to the savings provider.
+ */
+declare function convertResupplyMarketsToResponse(raw: ResupplyMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Per-position Resupply detail attached to the debt row (raw strings). */
+interface ResupplyPositionInfo {
+    /** Internal borrow shares. NOT an amount — see `debt` for reUSD units. */
+    borrowShares: string;
+    /** Collateral in VAULT SHARES (the pair's own accounting unit). */
+    collateralShares: string;
+    /** `convertToAssets(1e18)` on the collateral vault at read time — the
+     *  factor that turned those shares into the reported underlying. ~1e15 for
+     *  Curve Lend vaults. */
+    collateralSharePrice: string;
+    /** The pair contract — the market id and every write target. */
+    pair: string;
+    /** The collateral vault (Curve Lend / Fraxlend 4626 share token). */
+    collateralVault: string;
+}
+
+/** Test seam — drops the roster + discovery caches. */
+declare function __resetResupplyUserCaches(): void;
+
 /** Off-chain `Market.predictEscrow(user)`. */
 declare function predictInverseEscrow(market: Address, escrowImplementation: Address, user: Address): Address;
 
@@ -3036,6 +3397,184 @@ interface InversePositionInfo {
     dbrDeficit: string;
     /** DBR signed balance (raw, may be negative). */
     dbrSignedBalance: string;
+    /** `DBR.debts(user)` (raw DOLA) — debt across ALL FiRM markets, which is
+     *  what burns DBR at 1 per DOLA-year. Chain-wide, repeated on every row. */
+    dbrTotalDebt: string;
+    /** Seconds until `dbrBalance` is exhausted at that burn ('0' if no debt). */
+    dbrRunwaySeconds: string;
+    /** Unix seconds of the projected depletion — past that point anyone can
+     *  force-replenish the account, charging the replenished DBR to its DOLA
+     *  debt at `replenishmentPriceBps`, and withdrawals freeze. Absent when
+     *  there is no debt. */
+    dbrDepletionTimestamp?: string;
+}
+
+/**
+ * Per-market snapshot of a LlamaLend market. Amounts are HUMAN units (the
+ * Curve API serves human numbers; the on-chain fallback normalizes to match).
+ * Rates are DECIMALS (0.0391 = 3.91% APR), nominal — never the compounded
+ * `borrowApy` the API also carries.
+ *
+ * `null` marks a value the active source could not provide; the converter
+ * degrades per field rather than dropping the market.
+ */
+interface LlamaLendMarketRaw {
+    market: LlamaLendMarketConfig;
+    /** Controller.total_debt — borrowed-token units (human). */
+    totalDebt: number | null;
+    /** Vault.totalAssets — borrowed-token units (human). */
+    totalSupplied: number | null;
+    /**
+     * Borrowable right now. v2: `Controller.available_balance()`. v1:
+     * `borrowedToken.balanceOf(controller)`. This is also the withdrawal
+     * ceiling for lenders — the vault cannot pay out what is lent.
+     */
+    availableToBorrow: number | null;
+    /** Nominal borrow APR as a decimal. */
+    borrowApr: number | null;
+    /** Nominal lend APR as a decimal. */
+    lendApr: number | null;
+    /** Collateral price in borrowed-token terms, from the AMM's EMA oracle. */
+    collateralPrice: number | null;
+    /** USD price of the collateral, API only (the chain read has no USD leg). */
+    collateralPriceUsd: number | null;
+    /** USD price of the borrowed token, API only. */
+    borrowedPriceUsd: number | null;
+    /**
+     * Effective collateral factor at the market's `defaultBands`, derived from
+     * `max_borrowable(1 unit, N)` divided by the oracle price.
+     *
+     * There is NO market-constant LTV in LlamaLend — the number moves with the
+     * band count. Measured on sreUSD/crvUSD: 0.991 at N=4 down to 0.886 at
+     * N=50. Reporting the N=4 maximum would flatter every risk comparison
+     * against Aave/Morpho, so the default N is what gets reported and the rest
+     * of the curve travels alongside in `bandLtv`.
+     */
+    collateralFactor: number | null;
+    /** `{ [N]: collateralFactor }` — the trade-off curve for the UI and sizer. */
+    bandLtv: {
+        [bands: string]: number;
+    } | null;
+    /**
+     * v2 borrow cap in borrowed-token units (human). `0` DISABLES borrowing —
+     * a fresh v2 market looks live but is not. `null` on v1 (uncapped).
+     */
+    borrowCap: number | null;
+    /** Whether new borrows are possible at all right now. */
+    borrowingEnabled: boolean;
+    /** Vault.maxDeposit — `0` disables deposits (v2 `max_supply`). */
+    maxDeposit: number | null;
+    /** Number of open loans, for the liquidations surface. */
+    nLoans: number | null;
+    /**
+     * Soft-liquidation state of the market as a whole: the AMM's active band.
+     * Not a per-user value, but it tells the UI whether the market is currently
+     * converting anyone's collateral.
+     */
+    activeBand: number | null;
+}
+/** Raw public-data batch for one LlamaLend chain (both generations together). */
+interface LlamaLendMarketsRaw {
+    /** The bare lender key, `LLAMALEND`. */
+    lender: string;
+    config: LlamaLendConfigChain | undefined;
+    chainData: LlamaLendChainData | undefined;
+    markets: LlamaLendMarketRaw[];
+    /** Which source filled the market rows. */
+    source: 'api' | 'chain' | 'none';
+}
+
+declare function fetchLlamaLendMarkets(lender: string, chainId: string): Promise<LlamaLendMarketsRaw>;
+
+/**
+ * Synthesized per-market lender key, e.g.
+ * `LLAMALEND_4F79FE450A2BAF833E8F50340BD230F5A3ECAFE9` (= the sreUSD/crvUSD
+ * market). Keyed by the CONTROLLER, which is what every write and every user
+ * read targets — the vault is a lookup off it. Address-suffixed
+ * (Teller/Exactly/Inverse convention); the chain id is not part of the key
+ * because chain scoping happens at the marketUid level.
+ *
+ * Both generations share this key space on purpose: to a user they are one
+ * protocol, and the Curve API returns them in one list. The `version` field on
+ * the market row is what encoders branch on.
+ */
+declare function llamaLendLenderKey(lender: string, controller: string): string;
+/** Recover `{ lender, controller }` from a per-market key (or undefined). */
+declare function llamaLendKeyParts(key: string): {
+    lender: string;
+    controller: string;
+} | undefined;
+/**
+ * Map the LlamaLend batch into the shared `MorphoGeneralPublicResponse` shape,
+ * keyed by `LLAMALEND_<CONTROLLER_ADDR>` — one key per market.
+ *
+ * Per market, two entries in the isolated-pair layout:
+ *
+ *  - COLLATERAL entry — deposit-only. `collateralFactor` is the LTV AT THE
+ *    MARKET'S DEFAULT BAND COUNT, because LlamaLend has no market-constant
+ *    LTV: it is a function of `N` and moves 0.886..0.991 on a single market.
+ *    The whole curve rides along in `params.market.llamalend.bandLtv` so the
+ *    UI can show the trade-off and the leverage sizer can use the real number
+ *    for the `N` the user actually picks.
+ *  - LOAN entry — the borrowed token. Supply side is the ERC-4626 vault, so
+ *    unlike Inverse this one HAS `totalDeposits`.
+ *
+ * SOFT LIQUIDATION is the thing this shape cannot express natively, so it is
+ * carried explicitly in the descriptor. `liquidationPenalty` here is the HARD
+ * liquidation bonus only — it applies below the entire band range. Inside the
+ * range a position is converted gradually through the market's own AMM with no
+ * penalty at all, and a consumer that renders `liquidationPenalty` as "what
+ * you lose when the price hits X" is describing the wrong event.
+ */
+declare function convertLlamaLendMarketsToResponse(raw: LlamaLendMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/**
+ * Per-position LlamaLend detail attached to the debt row (raw strings unless
+ * noted).
+ *
+ * The two fields a consumer must not ignore:
+ *
+ *  - `softLiquidating` / `priceUpper` / `priceLower` — a LlamaLend position
+ *    does not have a liquidation price. It has a band RANGE, and it starts
+ *    converting collateral into the borrowed token as soon as the oracle
+ *    enters that range. Rendering a single number here misrepresents the
+ *    protocol.
+ *  - `bandCollateralInBorrowed` — the borrowed-token leg the LLAMMA has
+ *    already produced from the user's collateral. It sits inside the position,
+ *    offsets debt, and is NOT a wallet balance.
+ */
+interface LlamaLendPositionInfo {
+    /** Signed health, WAD. `< 0` ⇒ hard-liquidatable. */
+    health: string;
+    /** Upper bound of the soft-liquidation band range, WAD. */
+    priceUpper: string;
+    /** Lower bound of the soft-liquidation band range, WAD. */
+    priceLower: string;
+    /** Band indices `[n1, n2]` the collateral currently occupies. */
+    bands: [number, number] | undefined;
+    /** Band count `N` chosen at loan creation — IMMUTABLE for the loan's life. */
+    bandCount: number;
+    /**
+     * Borrowed-token amount held inside the user's bands (raw). Non-zero means
+     * the position IS or HAS BEEN in soft liquidation.
+     */
+    bandCollateralInBorrowed: string;
+    /** True when the LLAMMA currently holds a borrowed-token leg for this user. */
+    softLiquidating: boolean;
+    /**
+     * Whether the probed spender holds the Controller's boolean grant for this
+     * market. FAILS CLOSED — older-blueprint controllers have no `approval`
+     * method, the call fails, and this reads `false`, which is correct.
+     */
+    delegated: boolean;
+    /** Whether the market's Controller supports delegation at all. */
+    supportsDelegation: boolean;
+    /** Market generation — the leverage/encoder ABIs differ. */
+    version: 1 | 2;
 }
 
 /**
@@ -3140,6 +3679,115 @@ interface UsddPositionInfo {
     ilk: string;
 }
 
+/**
+ * One Frankencoin market (= one ORIGINAL position) after the on-chain batch.
+ * Raw bigints; `null` = failed allowFailure read.
+ */
+interface FrankencoinMarketRaw {
+    market: FrankencoinMarketConfig;
+    /** Owner-declared liquidation price, 36-dec scaled vs collateral decimals. */
+    price: bigint | null;
+    /** FACE debt on the original itself (clones carry their own). */
+    minted: bigint | null;
+    /** ZCHF the original + its clones may still draw — market borrow capacity. */
+    availableForClones: bigint | null;
+    /** Collateral custodied by the ORIGINAL position contract. */
+    collateralBalance: bigint | null;
+    /** Hub lead rate + risk premium, ppm. */
+    annualInterestPPM: bigint | null;
+    /** Upfront fee for minting now (pro-rata to expiry), ppm. */
+    currentFeePPM: bigint | null;
+    /** Withheld into the equity reserve at mint, ppm. */
+    reserveContribution: bigint | null;
+    /** Non-zero while a Dutch-auction challenge is running. */
+    challengedAmount: bigint | null;
+    expiration: bigint | null;
+    isClosed: boolean | null;
+}
+interface FrankencoinMarketsRaw {
+    lender: string;
+    config?: FrankencoinConfigChain;
+    chainData?: FrankencoinChainData;
+    markets: FrankencoinMarketRaw[];
+}
+
+/**
+ * Fetch all market data of ONE Frankencoin deployment — FULLY ON-CHAIN via
+ * one retrying multicall over the curated ORIGINAL-position roster from
+ * lender-metadata (`frankencoinConfig` / `frankencoinMarkets`, generated by
+ * its `update:frankencoin` job, which filters to V2 + open + a priceable
+ * collateral allowlist).
+ *
+ * Only originals are read here: they carry the terms AND the market-level
+ * borrow capacity (`availableForClones`). Clones are USER positions and are
+ * resolved per-account in the user-data path.
+ *
+ * NB `price` is the owner-DECLARED liquidation price, not an oracle quote —
+ * see the converter for how that is surfaced.
+ */
+declare function fetchFrankencoinMarkets(lender: string, chainId: string): Promise<FrankencoinMarketsRaw>;
+
+/**
+ * Synthesized per-market lender key, e.g.
+ * `FRANKENCOIN_1_5F2C10F7…` — one per ORIGINAL position. The chain id is part
+ * of the key (Fluid/River convention) even though Frankencoin is
+ * Ethereum-only today, so an L2 hub would not collide.
+ */
+declare function frankencoinLenderKey(lender: string, chainId: string | number, position: string): string;
+/** Recover `{ lender, chainId, position }` from a per-market key. */
+declare function frankencoinKeyParts(key: string): {
+    lender: string;
+    chainId: string;
+    position: string;
+} | undefined;
+/**
+ * Map one Frankencoin deployment's on-chain batch into the shared
+ * `MorphoGeneralPublicResponse` shape, keyed `FRANKENCOIN_<chainId>_<ORIGINAL>`.
+ *
+ * Three modelling decisions worth knowing (all from FRANKENCOIN_PLAN.md):
+ *
+ *  - **The liquidation price is owner-DECLARED, not an oracle.** `price` is
+ *    36-dec scaled against the collateral's decimals and is policed by a
+ *    Dutch-auction challenge game. We surface it as the LIQUIDATION price
+ *    (it defines `collateralFactor = 1`, i.e. minting is allowed up to
+ *    `coll × price`) but value collateral with OUR price feeds. The
+ *    divergence between the two is the risk signal, and it is carried
+ *    verbatim in `params.market.frankencoin.declaredPrice` so a consumer can
+ *    compute it. Never present the resulting health as a protocol invariant.
+ *  - **Debt ≠ proceeds.** `minted` is FACE debt including the withheld
+ *    `reserveContribution` (10–40 %) plus the upfront pro-rata fee. Both
+ *    ppm figures ride along in the descriptor so a quote layer can convert.
+ *  - **Positions expire.** `expiration` is surfaced and an expired market is
+ *    reported halted (its collateral is subject to forced sale).
+ *
+ * Per market: a COLLATERAL entry (the original's own collateral) and a LOAN
+ * entry (ZCHF). There is no protocol supply side — ZCHF is minted, and the
+ * earn leg is the separate savings module carried by the savings provider —
+ * so `totalDeposits` on the loan row is 0.
+ */
+declare function convertFrankencoinMarketsToResponse(raw: FrankencoinMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Per-position detail attached to the debt row (raw strings). */
+interface FrankencoinPositionInfo {
+    /** The position contract — the sub-account id and every write op's target. */
+    position: string;
+    /** The ORIGINAL this position was cloned from (its market). */
+    original: string;
+    /** Owner-declared liquidation price (raw, 36-dec scaled). */
+    declaredPrice: string;
+    /** Unix seconds; a position past this is subject to forced sale. */
+    expiration: string;
+    /** Non-zero while a Dutch-auction challenge is running against it. */
+    challengedAmount: string;
+    /** ppm withheld into the equity reserve — needed to quote a close, since
+     *  repaying burns with reserve credit and costs LESS than `minted`. */
+    reserveContributionPPM: string;
+}
+
 /**
  * Raw on-chain read for ONE Teller `LenderCommitmentGroup` pool. All amounts are
  * raw token base units; `minRateBps` is the pool's min borrow APR in BASIS
@@ -7618,8 +8266,18 @@ declare function parseRawRpcBatchResponses(batches: RawRpcBatch[], batchResponse
  * Parses multicall3 aggregate3 responses
  * The response contains an array of {success, returnData} tuples
  * Each returnData needs to be decoded using the original call's ABI
+ *
+ * `permanentFailures`, when supplied, is filled with the indices of calls that
+ * failed DETERMINISTICALLY. This path can tell them apart with certainty, which
+ * the viem path can only infer: if the batch response itself came back, the
+ * transport worked, so a `success: false` entry inside it is a revert — the
+ * chain's answer, not a lost read. Only a batch-level error is a lost read.
+ *
+ * The distinction matters downstream: a cross-margin lender voids its whole set
+ * on a lost read, and without this a single always-reverting market would void
+ * a perfectly good position on every request.
  */
-declare function parseMulticallRpcResponses(responses: RawRpcResponse[], batches: MulticallRpcBatch[], allowFailure?: boolean): any[];
+declare function parseMulticallRpcResponses(responses: RawRpcResponse[], batches: MulticallRpcBatch[], allowFailure?: boolean, permanentFailures?: Set<number>): any[];
 
 type TokenEntry = {
     chainId: string;
@@ -7712,4 +8370,1058 @@ interface FetchTokenBalancesOptions {
  */
 declare function fetchTokenBalances(chainId: string, account: string, tokens: string[], options?: FetchTokenBalancesOptions): Promise<TokenBalanceResult>;
 
-export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, ApiBookSource, type AprData, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type CoreValidators, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, EXACTLY_LENDER_KEY, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExtraValidationCall, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallRpcBatch, type NumberMap, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, TermSubgraphSource, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UsddMarketRaw, type UsddMarketsRaw, type UsddPositionInfo, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey };
+/**
+ * Term sheets — a structured, per-`marketUid` description of every lend and
+ * borrow offer we serve.
+ *
+ * One shape for pool lenders, fixed-term lenders, CDPs and vaults, so an
+ * integrator reads ONE object instead of ~15 protocol-specific fields plus a
+ * per-lender mental model. See [TERM_SHEET_PLAN.md](../../../../TERM_SHEET_PLAN.md)
+ * for the design rationale and the per-lender coverage matrix.
+ *
+ * ## Conventions that hold everywhere in this file
+ *
+ * - **Rates are nominal APR in PERCENT** (`3.85` = 3.85 %/yr), never a
+ *   fraction and never an APY. This is the package-wide convention.
+ * - **Factors are fractions** (`0.85` = 85 % LTV) — matching `LenderConfigData`.
+ * - **Durations are SECONDS**, timestamps are **unix seconds**.
+ * - **Raw amounts are decimal strings** in base units; human amounts are
+ *   `number`.
+ * - Every string union is deliberately OPEN (`| (string & {})`) so a new
+ *   lender can introduce a member without breaking a consumer's exhaustive
+ *   switch. Consumers MUST have a `default` branch and fall back to
+ *   `info.headline`.
+ */
+/** Nominal APR in percent (`3.85` = 3.85 %/yr). Never a fraction, never APY. */
+type AprPercent = number;
+/**
+ * Open-enum helper. `Open<'a' | 'b'>` keeps autocomplete for the known members
+ * while still accepting any string, so adding a member later is an ADDITIVE
+ * change rather than a breaking one.
+ */
+type Open<T extends string> = T | (string & {});
+/** Compact token reference — enough to render without a second lookup. */
+interface TermAssetRef {
+    chainId: string;
+    /** Lowercased contract address. */
+    address: string;
+    symbol?: string;
+    name?: string;
+    decimals?: number;
+    assetGroup?: string;
+    logoURI?: string;
+}
+/**
+ * Machine tags for filtering/faceting. DERIVED from the structured fields in
+ * `tags.ts` — never hand-written per lender, so they cannot drift from the
+ * numbers they summarize.
+ */
+type TermTag = Open<'fixed-rate' | 'variable-rate' | 'user-set-rate' | 'zero-interest' | 'prepaid-interest' | 'nav-accrual' | 'has-maturity' | 'perpetual' | 'rolling-duration' | 'static-debt' | 'accruing-debt' | 'time-liquidation' | 'price-liquidation' | 'redeemable' | 'no-liquidation' | 'full-collateral-seizure' | 'early-exit-free' | 'early-exit-penalty' | 'early-exit-discount' | 'exit-instant' | 'exit-capped' | 'exit-cooldown' | 'exit-queued' | 'exit-market-sale' | 'exit-may-be-impossible' | 'permissioned' | 'capped' | 'cap-full' | 'first-loss' | 'socialized-loss' | 'physical-delivery' | 'undercollateralized' | 'nav-attested' | 'immutable' | 'no-timelock' | 'eoa-controlled' | 'points-rewards' | 'oracle-flagged' | 'no-oracle'>;
+/** Human-facing copy for one side of a term sheet. */
+interface TermInfo {
+    /**
+     * ≤ ~100 chars, templated from live numbers, ready to render.
+     * `"Fixed 4.12 % until 3 Sep 2026 · repay any time at face value"`.
+     *
+     * ALWAYS populated — it is the graceful-degradation path for a consumer
+     * that does not recognise a newer enum member.
+     */
+    headline: string;
+    /** 1–3 sentences. Invariant prose lives on the profile; this interpolates
+     *  the market's own values. */
+    description: string;
+    /** Ready-to-display consequences, most important first. */
+    implications?: string[];
+    tags: TermTag[];
+}
+type RateKind = Open<
+/** Utilization IRM (Aave, Compound, Morpho, Silo, Euler, Fluid…). */
+'variable-curve'
+/** Governance-set with no curve (USDD stability fee, Spark `vsr`). */
+ | 'variable-managed'
+/** Borrower picks the rate (Liquity family). */
+ | 'user-set'
+/** Locked for a maturity (Exactly, Midnight, Term, TermMax, Teller, Lista). */
+ | 'fixed-term'
+/** Locked, no maturity. Reserved — nothing uses it today. */
+ | 'fixed-open'
+/** No ongoing rate at all (River); cost is a one-off fee. */
+ | 'zero-interest'
+/** Interest prepaid in a separate token (Inverse DBR). */
+ | 'prepaid'
+/** Share price tracks an attested NAV (Re, Apyx, USPC). */
+ | 'nav-accrual'
+/** Pure collateral leg — no yield. */
+ | 'none'>;
+/** One reward program. Identity matters: points are not a bankable APR. */
+interface RewardTerm {
+    /** Absent for points programs — that absence IS the signal. */
+    asset?: TermAssetRef;
+    kind: Open<'token' | 'points' | 'unknown'>;
+    apr: AprPercent;
+    side: 'supply' | 'borrow';
+    /** How it is realized — decides whether the APR is actually bankable. */
+    claim: Open<'accrual' | 'merkl' | 'manual' | 'none'>;
+    /** Program end, where known. An APR with two weeks left is not an APR. */
+    endsAt?: number;
+    /**
+     * `true` ⇒ not priceable (points). MUST be shown separately and is
+     * deliberately EXCLUDED from `RateTerms.aprTotal`.
+     */
+    indicative?: boolean;
+}
+/** One entry in a fixed-term rate menu. Mirrors `MarketTermEntry`. */
+interface RateMenuEntry {
+    /** LENDER-SPECIFIC: Exactly/TermMax = unix maturity, Teller = duration
+     *  seconds, Lista = broker product id, Midnight/Term = `0`. */
+    termId: number;
+    durationSecs: number;
+    durationDays: number;
+    /** Borrow APR at this term. */
+    apr: AprPercent;
+    /** Lend APR at this term, where the lender quotes both sides. */
+    depositApr?: AprPercent;
+    /** Borrowable liquidity at this term, human units. */
+    available?: number;
+}
+interface RateTerms {
+    kind: RateKind;
+    /** Base rate only — no rewards, no intrinsic yield. */
+    apr: AprPercent;
+    components: {
+        base: AprPercent;
+        /** Priceable rewards only. */
+        rewards?: AprPercent;
+        /** Underlying/LST yield the asset earns by itself. */
+        intrinsic?: AprPercent;
+    };
+    /** `base + priceable rewards + intrinsic` — the headline number. */
+    aprTotal: AprPercent;
+    /** Carried explicitly even though it has one value today: a silent
+     *  APR→APY change would be the classic undetectable break. */
+    basis: 'apr-nominal';
+    compounding: Open<'per-second' | 'per-block' | 'none' | 'unknown'>;
+    source: Open<'utilization-curve' | 'orderbook' | 'auction' | 'governance' | 'borrower' | 'oracle' | 'api' | 'derived'>;
+    /** Is the rate locked for the life of the position? */
+    isLocked: boolean;
+    /** Protocol-enforced bounds (Liquity min/max, Morpho rateCap/rateFloor). */
+    minApr?: AprPercent;
+    maxApr?: AprPercent;
+    /** Per-program reward detail — token identity, claim path, end date. */
+    rewards?: RewardTerm[];
+    /** Rate menu when the market offers several terms at once. */
+    menu?: RateMenuEntry[];
+    /** Size the quote is valid for, when the rate is depth-dependent. */
+    quote?: {
+        assets: number;
+        basis: Open<'marginal' | 'average'>;
+    };
+    lastChangedAt?: number;
+}
+interface MaturityTerms {
+    kind: Open<'perpetual' | 'fixed-date' | 'rolling-duration'>;
+    /** unix seconds; `kind: 'fixed-date'`. */
+    maturity?: number;
+    /** ISO-8601 mirror so consumers need not re-format. */
+    maturityIso?: string;
+    /** Snapshot — derive live from `maturity` for a countdown. */
+    secondsToMaturity?: number;
+    /** `kind: 'rolling-duration'` (Teller, Lista broker). */
+    minDurationSecs?: number;
+    maxDurationSecs?: number;
+    /**
+     * What happens at/after maturity if NOBODY acts. The field that most
+     * surprises users — outcomes range from "interest simply stops" to
+     * "liquidated within five minutes, losing all collateral".
+     */
+    atMaturity?: Open<'stops-earning' | 'penalty-accrues' | 'liquidatable' | 'default-seizure' | 'physical-delivery' | 'refinanced' | 'auto-roll' | 'none'>;
+    /** Grace window before `atMaturity` bites (Teller ~300 s, TermMax 7200 s). */
+    graceSecs?: number;
+}
+type FeeWhen = Open<'entry' | 'ongoing' | 'exit' | 'late' | 'liquidation' | 'performance'>;
+/**
+ * One charge, in a shape general enough that a NEW fee is data rather than a
+ * schema change. Replaces the current scatter: `originationFee`,
+ * `withdrawFeeBps`, `rates.fee`, `fixedTerm.fees.*`, `river.mintFeeRate`,
+ * `liquity.gasCompensation`.
+ */
+interface FeeTerm {
+    /** Stable slug — the join key for UI copy and filtering. */
+    id: Open<'origination' | 'late-penalty' | 'early-repay-penalty' | 'early-repay-discount' | 'continuous' | 'settlement' | 'instant-exit' | 'performance' | 'reserve-factor' | 'gas-compensation' | 'redemption' | 'claim' | 'liquidation-bonus'>;
+    /** Human label — lets an unknown `id` still render correctly. */
+    label: string;
+    when: FeeWhen;
+    unit: Open<'apr-percent' | 'percent' | 'bps' | 'absolute'>;
+    basis: Open<'principal' | 'face-value' | 'yield' | 'collateral' | 'shares' | 'debt-repaid'>;
+    /**
+     * A NEGATIVE value is legal and means a REBATE (Exactly's early-repay
+     * discount). Sign is load-bearing — never take an absolute value.
+     */
+    value: number;
+    payee?: Open<'protocol' | 'lenders' | 'liquidator' | 'curator' | 'gas-refund'>;
+    /** Governance-mutable ⇒ this is a snapshot; re-verify before quoting. */
+    mutable?: boolean;
+    /** Only resolvable at action time (Exactly discount, TermMax curve price). */
+    indicative?: boolean;
+    /** Decaying/scheduled fees (Apyx: 3.40 % → 0 over 20 days). */
+    schedule?: {
+        afterSecs: number;
+        value: number;
+    }[];
+    description?: string;
+}
+/** Superset of `SavingsWithdrawalMode` + `LstWithdrawalMode`, plus the two
+ *  lending-side exits neither covers. */
+type SupplyExitMode = Open<'instant' | 'instant-capped' | 'instant-or-queued' | 'fee-or-queued' | 'fixed-cooldown' | 'queued' | 'request-based'
+/** Sell the instrument on a book (Term, TermMax, Midnight). */
+ | 'market-sale'
+/** No early exit at all. */
+ | 'at-maturity' | 'off-chain' | 'dex-only'>;
+interface SupplyExitTerms {
+    mode: SupplyExitMode;
+    /** Coarse alias — identical semantics to `VaultClassificationFields.redemptionType`. */
+    settlement: Open<'sync' | 'async'>;
+    cooldownSecs?: number;
+    /** Claim-window constraints (Apyx: blocked 3 d, free at 20 d). */
+    claimWindow?: {
+        earliestSecs?: number;
+        freeAfterSecs?: number;
+    };
+    /** What can actually leave right now. */
+    liquidity?: {
+        assets: number;
+        assetsUsd?: number;
+        ratio?: number;
+    };
+    partialAllowed: boolean;
+    /**
+     * Does exiting early cost an UNKNOWN amount?
+     * `none` par · `haircut-formula` deterministic discount ·
+     * `market-price` you sell into a book · `may-be-impossible` the book can be
+     * empty.
+     */
+    priceRisk: Open<'none' | 'haircut-formula' | 'market-price' | 'may-be-impossible'>;
+    cancellable?: boolean;
+    /** The `when: 'exit' | 'performance'` subset of the side's fees. */
+    fees: FeeTerm[];
+}
+interface BorrowExitTerms {
+    /** Three signs exist across our lenders: `discount` is a REBATE (Exactly). */
+    earlyRepay: Open<'free' | 'discount' | 'penalty' | 'market-price' | 'not-allowed'>;
+    atMaturityCost: Open<'face' | 'accrued'>;
+    lateBehaviour: Open<'penalty-accrues' | 'liquidatable' | 'default-seizure' | 'refinanced' | 'none'>;
+    partialAllowed: boolean;
+    /** Dust floor — Liquity `minDebt`, Morpho/Lista `minLoan`. Raw base units. */
+    minDebt?: string;
+    /** Over-repay REVERTS (Midnight `uint128` underflow) — a real footgun. */
+    overRepayReverts?: boolean;
+    fees: FeeTerm[];
+}
+interface LiquidationTerms {
+    trigger: Open<'price' | 'time' | 'price-and-time' | 'redemption' | 'none'>;
+    /** Max LTV at open. */
+    ltv?: number;
+    /** Threshold at which liquidation becomes possible. */
+    liquidationLtv?: number;
+    /** Fraction of repaid debt paid to the liquidator on top of par. */
+    penalty: number;
+    closeFactor: number;
+    targetHealthFactor?: number;
+    /**
+     * `full-collateral` is the Teller case: the liquidator takes the ENTIRE
+     * escrow, not a proportional slice — ~2× the debt at 50 % LTV.
+     */
+    seizure: Open<'proportional' | 'full-collateral'>;
+    /** Liquity/River: collateral redeemable at par while perfectly healthy. */
+    redeemable?: boolean;
+    gracePeriodSecs?: number;
+}
+interface CounterpartyTerms {
+    kind: Open<'pool' | 'orderbook' | 'auction' | 'broker' | 'cdp' | 'p2p' | 'vault-strategy' | 'off-chain-credit'>;
+    address?: string;
+    /** The trust question, one field. */
+    solvency: Open<'overcollateralized' | 'tranched-senior' | 'tranched-junior' | 'undercollateralized' | 'nav-attested'>;
+    socializedLoss?: boolean;
+    curator?: string;
+}
+/** Origination window for auction-gated markets (Term Finance). */
+interface AuctionWindow {
+    status: Open<'upcoming' | 'open' | 'revealing' | 'closed'>;
+    canBorrow: boolean;
+    canLend: boolean;
+    secondsUntilClose?: number;
+    id?: string;
+    startTime?: number;
+    revealTime?: number;
+    endTime?: number;
+    minBorrowAmount?: string;
+    minLendAmount?: string;
+}
+/** What must be granted BEFORE an action can even be built. */
+type PermissionKind = Open<'token-approval' | 'lender-delegation' | 'manager-authorization' | 'eip712-permit' | 'nft-approval' | 'operator-set'
+/** Contract callers must be governance-approved (Inverse, Fraxlend). */
+ | 'caller-allowlist'>;
+interface AvailabilityTerms {
+    /** Gate CTAs on THIS and nothing else — it already folds in caps, freezes,
+     *  auction windows and gating. */
+    canOpen: boolean;
+    canClose: boolean;
+    /** Machine-readable reason when `canOpen` is false. */
+    blockedBy?: Open<'frozen' | 'paused' | 'cap-full' | 'auction-closed' | 'no-liquidity' | 'not-whitelisted' | 'shutdown' | 'disabled'>;
+    gating: Open<'permissionless' | 'whitelist' | 'attestation' | 'kyc' | 'allowlist-contract'>;
+    /** Absent ⇒ no window applies. NOT the same as `closed`. */
+    window?: AuctionWindow;
+    /** Raw base units. */
+    minSize?: string;
+    cap?: string;
+    /** 0..1 — how full the cap is. */
+    capUtilization?: number;
+    requires?: PermissionKind[];
+}
+interface PositionConstraints {
+    /** Aave isolation mode: capped debt, no collateral mixing. */
+    isolation?: {
+        enabled: boolean;
+        debtCeiling?: string;
+        ceilingUtilization?: number;
+    };
+    /** Borrowing this asset forbids borrowing any other in the same account. */
+    siloedBorrowing?: boolean;
+    crossMargin: boolean;
+    /**
+     * How a position is ADDRESSED. `loanId` already means five different things
+     * across our lenders and `termId` six — making the model explicit is
+     * cheaper than making every integrator rediscover it.
+     */
+    positionModel: Open<'account' | 'sub-account' | 'nft' | 'cdp-id' | 'loan-id' | 'escrow'>;
+    /** One line saying what the id in `loanId`/`posId` actually IS here. */
+    positionIdMeaning?: string;
+    maxPositions?: number;
+    /**
+     * What this fetch actually SAW, as opposed to what the lender family
+     * implies. Kept separate from `crossMargin` / `positionModel` on purpose:
+     * those are family-level truths from the registry, these are per-fetch
+     * observations, and collapsing the two would let a thin chain (a lender
+     * listing one asset today) masquerade as a structural property.
+     *
+     * Useful precisely where they DISAGREE — e.g. Fluid is registered isolated
+     * because its T1 vaults dominate, but its T2–T4 "smart" vaults genuinely
+     * pool two collaterals; a `collateralAssetCount > 1` on a Fluid row is the
+     * signal that this particular vault is one of them.
+     */
+    observed?: {
+        /** Distinct collateral assets this market actually accepts, this fetch. */
+        collateralAssetCount: number;
+        /** Markets seen under this lender key on this chain, this fetch. */
+        marketCount: number;
+        /** Does the lender key fan out to many markets (registry answer)? */
+        multiMarketKey: boolean;
+    };
+}
+type AdminKind = Open<'EOA' | 'SAFE' | 'TIMELOCK' | 'GOVERNOR' | 'GOVERNANCE' | 'CUSTOM' | 'UNKNOWN'>;
+type GovernancePower = Open<'pause-deposits' | 'pause-withdrawals' | 'pause-borrows' | 'freeze-market' | 'change-ltv' | 'change-rate' | 'change-fees' | 'set-caps' | 'add-collateral' | 'swap-oracle' | 'upgrade-implementation' | 'blacklist' | 'seize-funds' | 'reprice-pending-redemptions'>;
+interface GovernanceTerms {
+    mutability: Open<'immutable' | 'governed' | 'unknown'>;
+    /** The governance root, after hopping proxy admins / timelock admins. */
+    controller?: string;
+    controllerKind?: AdminKind;
+    safe?: {
+        threshold: number;
+        owners: number;
+    };
+    /**
+     * Enforced delay in SECONDS between a parameter change being queued and it
+     * taking effect — the holder's NOTICE PERIOD. `0`, or any `controllerKind`
+     * that is not `TIMELOCK`, means a parameter can change in the very next
+     * block with no warning.
+     *
+     * **This is NOT a withdrawal lock.** `SupplyExitTerms.cooldownSecs` is how
+     * long YOUR money is stuck; this is how long you have to react to someone
+     * else changing the deal. Never merge or sum the two.
+     */
+    timelockSecs?: number;
+    timelockSource?: Open<'on-chain' | 'screened' | 'metadata'>;
+    /**
+     * The controller IS a timelock but its delay could not be read. Distinct
+     * from `timelockSecs: undefined` on a non-timelock root, which genuinely
+     * means "no notice period" — conflating the two would raise a false alarm
+     * on the safest governance shape.
+     */
+    timelockUnknown?: boolean;
+    tier?: Open<'low' | 'medium' | 'high' | 'unknown'>;
+    score?: number;
+    powers?: GovernancePower[];
+    roles?: {
+        owner?: string;
+        curator?: string;
+        guardian?: string;
+        feeRecipient?: string;
+    };
+    /** Governance screens refresh far slower than rates — own timestamp. */
+    asOfScreen?: number;
+}
+type OracleBand = Open<'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'>;
+interface OracleTerms {
+    /**
+     * `none` is MEANINGFUL, not missing data: Teller liquidates on TIME and has
+     * no oracle and no health factor anywhere in its trigger.
+     */
+    kind: Open<'price-feed' | 'nav-attested' | 'none'>;
+    /**
+     * THE oracle for this `marketUid` — SINGULAR, lowercased. Verified across
+     * the full oracle classification: 8,993 marketUids, 0 with more than one
+     * address. Singularity holds because `marketUid` granularity is already
+     * per-asset; the array in the legacy `oracleInfo.feeds[]` is an artifact of
+     * hanging off the lender/params level instead.
+     *
+     * For a composite/cross adapter this is the ADAPTER — the address whose
+     * failure or replacement moves this market's price.
+     */
+    address?: string;
+    /** Underlying feeds when the adapter composes several and the classifier
+     *  decomposed them. `address` stays the single source of truth. */
+    components?: string[];
+    provider?: string;
+    /** Decoded reported pair, e.g. `"ETH / USD"`. */
+    priceDescription?: string;
+    /** What it SHOULD report, e.g. `"WETH / USD"`. */
+    intendedPair?: string;
+    correctAsset?: boolean | null;
+    correctNumeraire?: boolean | null;
+    fixedRate?: boolean;
+    score?: number;
+    band?: OracleBand;
+    flags?: string[];
+    /** Can the oracle be swapped/upgraded, and by whom. On an otherwise
+     *  IMMUTABLE market this is the ONLY mutable trust vector. */
+    mutability?: {
+        mutable: boolean;
+        kind: Open<'IMMUTABLE' | 'PROXY' | 'AUTHORITY' | 'UNKNOWN'>;
+        controller?: string;
+        controllerKind?: AdminKind;
+        timelockSecs?: number;
+    };
+    heartbeatSecs?: number;
+    lastUpdateAt?: number;
+}
+interface AssetQuality {
+    /** 1 (best) … 5 (worst). */
+    riskScore?: number;
+    source?: Open<'whitelist' | 'default' | 'curated'>;
+    /** On-chain USD liquidity available to absorb a liquidation — the number
+     *  that decides whether the LLTV is actually enforceable. */
+    liquidityUsd?: number;
+    /** The TOKEN CONTRACT's own governance, distinct from the market's. An
+     *  upgradeable, pausable collateral is a supplier risk even on an
+     *  immutable market. */
+    governanceScore?: number;
+    governanceLevel?: Open<'green' | 'amber' | 'red'>;
+    upgradeable?: boolean;
+    canPause?: boolean;
+    adminKind?: AdminKind;
+}
+interface ExposureEntry {
+    asset: TermAssetRef;
+    /** That asset's OWN row in this lender — join key to its full term sheet. */
+    marketUid?: string;
+    via: Open<'collateral' | 'vault-allocation' | 'strategy' | 'idle'>;
+    assets?: number;
+    assetsUsd?: number;
+    /** 0..100. ABSENT when `weightBasis === 'unweighted'`. */
+    weightPct?: number;
+    ltv?: number;
+    liquidationLtv?: number;
+    liquidationPenalty?: number;
+    /** The collateral's OWN oracle. Your deposit's safety depends on the oracle
+     *  pricing SOMEONE ELSE'S collateral. */
+    oracle?: OracleTerms;
+    quality?: AssetQuality;
+}
+interface ExposureTerms {
+    count: number;
+    /**
+     * How `weightPct` was obtained, and therefore how much to trust it.
+     * `unweighted` = POOLED lenders: Aave/Compound do not record which
+     * collateral backs which borrow on-chain, so the list is the ACCEPTED SET,
+     * not a measured split. Do not render a pie chart from it.
+     */
+    weightBasis: Open<'debt' | 'allocation' | 'unweighted'>;
+    worstRiskScore?: number;
+    worstOracleBand?: OracleBand;
+    /** Largest single exposure's `weightPct` — the concentration signal. Only
+     *  meaningful when `weightBasis !== 'unweighted'`. */
+    topWeightPct?: number;
+    items: ExposureEntry[];
+}
+interface UtilizationTerms {
+    /** borrowed / supplied, 0..1 — the IRM input for this market. */
+    utilization: number;
+    /**
+     * The basis the ratio is computed over. NOT always this row: rates for
+     * shared-liquidity protocols are set on a larger pool, and a simulation
+     * must shift THAT, not the row totals.
+     */
+    basis: Open<'market' | 'hub' | 'liquidity-layer' | 'pool'>;
+    irmTotalDeposits?: number;
+    irmTotalDebt?: number;
+    /** Where the curve steepens — headroom before the rate jumps. */
+    targetUtilization?: number;
+    kinkUtilization?: number;
+    /** 0..1. `1` = cap full and the side is closed. */
+    supplyCapUtilization?: number;
+    borrowCapUtilization?: number;
+    /** Fluid: share of collateral locked below the withdrawal limit. */
+    lockupRatio?: number;
+}
+/**
+ * A non-default risk category, expressed as a DELTA against the resolved
+ * default. `config` is a MAP keyed by category (Aave e-modes, Dolomite
+ * categories, Euler configs, Silo) — a single flat LTV silently reports the
+ * default and hides the rest, which on an Aave ETH-correlated e-mode is the
+ * difference between 80 % and 93 %.
+ */
+interface ModeVariant {
+    /** The `config` map key. `'0'` is the default on every lender. */
+    modeId: string;
+    label?: string;
+    isDefault: boolean;
+    entry?: Open<'automatic' | 'user-selected' | 'per-position'>;
+    liquidation?: Partial<LiquidationTerms>;
+    /**
+     * Mode-scoped and usually RESTRICTED: an e-mode typically narrows the
+     * accepted collateral to a correlated basket. Omitting it would make the
+     * headline LTV look obtainable against collateral the mode forbids.
+     */
+    acceptedCollateral?: ExposureTerms;
+    rate?: Partial<RateTerms>;
+    availability?: Partial<AvailabilityTerms>;
+}
+interface SupplyTermSheet {
+    /** Is this position earning, or is it just collateral? */
+    role: Open<'yield' | 'collateral' | 'both'>;
+    rate: RateTerms;
+    maturity: MaturityTerms;
+    exit: SupplyExitTerms;
+    /** ALL fees on this side, including the exit subset. */
+    fees: FeeTerm[];
+    /** What secures the debt drawn against this deposit. */
+    backedBy?: ExposureTerms;
+    modes?: ModeVariant[];
+    counterparty: CounterpartyTerms;
+    availability: AvailabilityTerms;
+    /** Is the supplied principal at risk beyond ordinary credit risk? */
+    principal: {
+        protected: boolean;
+        risks: Open<'bad-debt' | 'physical-delivery' | 'nav-drawdown' | 'first-loss' | 'depeg'>[];
+    };
+    info: TermInfo;
+    /** Namespaced escape hatch — see the promotion rule in TERM_SHEET_PLAN §13.5. */
+    ext?: Record<string, unknown>;
+}
+interface BorrowTermSheet {
+    rate: RateTerms;
+    maturity: MaturityTerms;
+    /**
+     * Does the amount owed GROW, or is it a static face value fixed at trade
+     * time? The single biggest departure from variable-rate intuition — four of
+     * six fixed-term lenders are static.
+     */
+    debtShape: Open<'accruing' | 'static-face' | 'prepaid'>;
+    exit: BorrowExitTerms;
+    /** Fully resolved for the DEFAULT mode. `modes[]` carries the rest. */
+    liquidation: LiquidationTerms;
+    /** What you may post, each with its own LTV, oracle and quality. */
+    acceptedCollateral?: ExposureTerms;
+    modes?: ModeVariant[];
+    fees: FeeTerm[];
+    counterparty: CounterpartyTerms;
+    availability: AvailabilityTerms;
+    info: TermInfo;
+    ext?: Record<string, unknown>;
+}
+/**
+ * Distinguishes "not applicable" from "not implemented yet" — the affordance
+ * that lets phases ship incrementally without lying. A missing `oracle` must
+ * never read as "this market has no oracle" when the truth is "we have not
+ * classified it".
+ */
+interface CoverageInfo {
+    /** Blocks genuinely computed for this market. */
+    present: string[];
+    /** Blocks that do NOT APPLY here — a positive fact. */
+    notApplicable?: Record<string, string>;
+    /** Blocks that WOULD apply but are not wired yet. */
+    pending?: Record<string, string>;
+}
+/** Current schema version. Bumped ONLY for removals/semantic/unit changes;
+ *  new optional fields and new enum members are additive. */
+declare const TERM_SHEET_SCHEMA_VERSION = 1;
+interface TermSheet {
+    schemaVersion: number;
+    /** unix seconds at fetch — everything here is a snapshot. */
+    asOf: number;
+    /** `<family>.<variant>@v<n>`, e.g. `aave-v3.pool@v1`. Points at the prose
+     *  catalogue so the per-market payload stays small. */
+    profileId: string;
+    /** The anchor this sheet describes. */
+    marketUid?: string;
+    lender?: string;
+    chainId?: string;
+    supply?: SupplyTermSheet;
+    borrow?: BorrowTermSheet;
+    /** Shared — these describe the MARKET, not a side. */
+    governance?: GovernanceTerms;
+    oracle?: OracleTerms;
+    utilization?: UtilizationTerms;
+    constraints?: PositionConstraints;
+    coverage?: CoverageInfo;
+    ext?: Record<string, unknown>;
+}
+/** Compact form for list endpoints — `?terms=digest`. */
+interface TermSheetDigest {
+    schemaVersion: number;
+    profileId: string;
+    marketUid?: string;
+    supply?: {
+        rateKind: RateKind;
+        aprTotal: AprPercent;
+        maturityKind: MaturityTerms['kind'];
+        maturity?: number;
+        exitMode: SupplyExitMode;
+        settlement: SupplyExitTerms['settlement'];
+        canOpen: boolean;
+        headline: string;
+        tags: TermTag[];
+        backedBy?: Omit<ExposureTerms, 'items'>;
+    };
+    borrow?: {
+        rateKind: RateKind;
+        apr: AprPercent;
+        maturityKind: MaturityTerms['kind'];
+        maturity?: number;
+        debtShape: BorrowTermSheet['debtShape'];
+        earlyRepay: BorrowExitTerms['earlyRepay'];
+        liquidationTrigger: LiquidationTerms['trigger'];
+        canOpen: boolean;
+        headline: string;
+        tags: TermTag[];
+        acceptedCollateral?: Omit<ExposureTerms, 'items'>;
+    };
+    oracle?: Pick<OracleTerms, 'kind' | 'address' | 'provider' | 'band'>;
+    governance?: Pick<GovernanceTerms, 'mutability' | 'controllerKind' | 'timelockSecs' | 'tier'>;
+    utilization?: number;
+}
+/** A term profile — the invariant prose, one per lender family × variant. */
+interface TermProfile {
+    id: string;
+    /** Display name, e.g. `Aave V3 pool market`. */
+    name: string;
+    /** Which lender family this covers. */
+    family: string;
+    supply?: {
+        description: string;
+        implications?: string[];
+    };
+    borrow?: {
+        description: string;
+        implications?: string[];
+    };
+    docsUrl?: string;
+}
+/** Deep-partial, for adapters that return only what they override. */
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends (infer U)[] ? U[] : T[K] extends object | undefined ? DeepPartial<NonNullable<T[K]>> : T[K];
+};
+
+/**
+ * The normalized input the builder reads.
+ *
+ * Deliberately NOT `PoolData` directly: the same market travels through this
+ * codebase in two casings — the in-package shape (`totalDepositsUSD`,
+ * `variableBorrowRate`) and the API-serialized shape (`totalDepositsUsd`,
+ * nested `caps`/`flags`/`config`). The builder must work on both, because it
+ * runs in-package during a fetch AND at the worker while proxying an origin
+ * response.
+ *
+ * So: one tolerant reader (`toTermSheetInput`) normalizes either shape into
+ * this interface, and the builder itself is pure over the normalized form.
+ */
+interface TermConfigEntry {
+    category: number | string;
+    label?: string;
+    borrowCollateralFactor?: number;
+    collateralFactor?: number;
+    borrowFactor?: number;
+    liquidationPenalty?: number;
+    closeFactor?: number;
+    targetHealthFactor?: number;
+    collateralDisabled?: boolean;
+    debtDisabled?: boolean;
+}
+interface TermRewardInput {
+    asset?: string;
+    depositRate?: number;
+    variableBorrowRate?: number;
+    stableBorrowRate?: number;
+    /** Merkl / points programs mark themselves; absent ⇒ a normal token. */
+    kind?: string;
+    endsAt?: number;
+    claim?: string;
+}
+interface TermMenuInput {
+    termId: number;
+    durationSecs: number;
+    durationDays: number;
+    apr: number;
+    depositApr?: number;
+    available?: number;
+}
+/** Normalized market facts the generic builder needs. */
+interface TermSheetInput {
+    marketUid: string;
+    lender: string;
+    chainId: string;
+    /** Underlying asset of THIS row. */
+    asset?: {
+        chainId?: string;
+        address?: string;
+        symbol?: string;
+        name?: string;
+        decimals?: number;
+        assetGroup?: string;
+        logoURI?: string;
+    };
+    underlying?: string;
+    decimals?: number;
+    depositRate?: number;
+    variableBorrowRate?: number;
+    stableBorrowRate?: number;
+    intrinsicYield?: number;
+    rewards?: TermRewardInput[];
+    rateModel?: string;
+    originationFee?: number;
+    totalDeposits?: number;
+    totalDebt?: number;
+    totalDebtStable?: number;
+    totalLiquidity?: number;
+    borrowLiquidity?: number;
+    totalDepositsUsd?: number;
+    totalDebtUsd?: number;
+    totalLiquidityUsd?: number;
+    utilization?: number;
+    irmTotalDeposits?: number;
+    irmTotalDebt?: number;
+    lockupRatio?: number;
+    supplyCap?: number;
+    borrowCap?: number;
+    debtCeiling?: string | number;
+    isActive?: boolean;
+    isFrozen?: boolean;
+    borrowingEnabled?: boolean;
+    depositsEnabled?: boolean;
+    collateralActive?: boolean;
+    hasStable?: boolean;
+    variableBorrowDisabled?: boolean;
+    config?: Record<string, TermConfigEntry>;
+    closeFactor?: number;
+    targetHealthFactor?: number;
+    fixedTerm?: {
+        model?: string;
+        maturity?: number;
+        fees?: {
+            continuousFeeApr?: number;
+            settlementFee?: number;
+            latePenaltyApr?: number;
+            originationFeePercent?: number;
+        };
+        earlyRepay?: {
+            kind?: string;
+        };
+        provider?: {
+            kind?: string;
+            address?: string;
+        };
+        auction?: Record<string, unknown>;
+    };
+    terms?: TermMenuInput[];
+    /** Market-level params (`params.market`) when the lender has them. */
+    market?: Record<string, unknown>;
+}
+/**
+ * Normalize either the in-package `PoolData`-ish row or an API `LendingMarket`
+ * item into {@link TermSheetInput}. Tolerant by design: a field missing under
+ * one casing is looked up under the other, and nested `caps`/`flags` bundles
+ * are unwrapped.
+ */
+declare function toTermSheetInput(row: Record<string, any>, ctx?: {
+    marketUid?: string;
+    lender?: string;
+    chainId?: string;
+    market?: Record<string, any>;
+    /**
+     * Item-level fixed-term descriptor. `/lending/latest` attaches `fixedTerm`
+     * to the LENDER item, not to each market row, so without this every
+     * fixed-term market would silently lose its maturity, its fees and its
+     * auction window. A row-level `fixedTerm` (how `/pools/latest` serializes
+     * it) is more specific and wins.
+     */
+    fixedTerm?: Record<string, any>;
+}): TermSheetInput;
+
+/**
+ * Accepted-collateral / backing set from the SIBLING rows of the same lender.
+ *
+ * Pooled lenders (Aave, Compound) do NOT record on-chain which collateral
+ * backs which borrow, so the result is the ACCEPTED SET with
+ * `weightBasis: 'unweighted'` and NO `weightPct` on any item. Inventing a
+ * TVL-proxy weight would look authoritative and be false — a large idle
+ * collateral market is not a large exposure.
+ */
+declare function buildExposures(input: TermSheetInput, siblings: TermSheetInput[], direction: 'backing' | 'accepted'): ExposureTerms | undefined;
+/** Deep merge an adapter's partial over the generic result. Arrays REPLACE. */
+declare function mergeDeep<T>(base: T, patch: DeepPartial<T> | undefined): T;
+/**
+ * Fill `info` (headline / description / tags) LAST, after adapters have run,
+ * so the prose always describes the final values rather than the generic
+ * guess. This is the mechanism that stops copy drifting from numbers.
+ */
+declare function finalizeInfo(sheet: TermSheet): TermSheet;
+interface BuildTermSheetOptions {
+    /** Unix seconds; injected so tests are deterministic. */
+    now?: number;
+    /** Other rows of the SAME lender+chain — used to derive the exposure set. */
+    siblings?: TermSheetInput[];
+    /** Adapter output, merged over the generic result. */
+    patch?: DeepPartial<TermSheet>;
+    profileId?: string;
+}
+/** Build one complete term sheet for one market row. */
+declare function buildTermSheet(input: TermSheetInput, opts?: BuildTermSheetOptions): TermSheet;
+
+/** Supply-side tags. Market-level tags are folded in by the caller. */
+declare function deriveSupplyTags(supply: SupplyTermSheet, market?: Pick<TermSheet, 'governance' | 'oracle'>): TermTag[];
+/** Borrow-side tags. */
+declare function deriveBorrowTags(borrow: BorrowTermSheet, market?: Pick<TermSheet, 'governance' | 'oracle'>): TermTag[];
+
+/**
+ * Severity model — PURE, derived only from structured fields.
+ *
+ * Space is the binding constraint at every display depth, so ranking has to be
+ * principled rather than per-lender taste. There is deliberately NO
+ * hand-maintained list of "scary markets": a newly integrated lender is
+ * classified correctly the moment its adapter sets the right fields.
+ *
+ * - `critical` — you can lose MORE than the amount at stake, or lose it
+ *   without doing anything wrong. This is the only tier that should gate a
+ *   signature.
+ * - `warn` — it costs money, or blocks you.
+ * - `info` — everything else.
+ */
+type Severity = 'critical' | 'warn' | 'info';
+interface SeverityFinding {
+    severity: Severity;
+    /** Stable slug — the join key for UI copy and for tests. */
+    id: string;
+    /** Ready-to-render sentence. */
+    message: string;
+    side: 'supply' | 'borrow' | 'market';
+}
+/** Sort findings most-severe-first, stable within a tier. */
+declare function rankFindings(findings: SeverityFinding[]): SeverityFinding[];
+declare function supplyFindings(supply: SupplyTermSheet): SeverityFinding[];
+declare function borrowFindings(borrow: BorrowTermSheet): SeverityFinding[];
+/**
+ * All findings for one side of a sheet, ranked most-severe-first. Pass
+ * `side: 'supply' | 'borrow'` — market-level findings are always included
+ * because governance and oracle affect both sides.
+ */
+declare function findingsFor(sheet: TermSheet, side: 'supply' | 'borrow'): SeverityFinding[];
+/** Does this side carry anything that should gate a signature? */
+declare function hasCritical(sheet: TermSheet, side: 'supply' | 'borrow'): boolean;
+
+/** `4.1234` → `"4.12 %"`; trims to 2dp, drops a trailing `.00`. */
+declare function pct(value: number | undefined, dp?: number): string;
+/** Duration in seconds → the coarsest human unit that stays honest. */
+declare function duration(secs: number | undefined): string;
+/** Unix seconds → `"3 Sep 2026"`. Locale-independent so snapshots are stable. */
+declare function shortDate(unixSecs: number | undefined): string;
+/** One fee → a self-contained phrase, correct even for an unrecognised `id`. */
+declare function feePhrase(fee: FeeTerm): string;
+/** Supply-side headline: ≤ ~100 chars, always populated. */
+declare function supplyHeadline(s: SupplyTermSheet): string;
+/** Borrow-side headline. */
+declare function borrowHeadline(b: BorrowTermSheet): string;
+/** Supply-side description — 1–3 sentences, market values interpolated. */
+declare function supplyDescription(s: SupplyTermSheet, sheet?: Pick<TermSheet, 'utilization'>): string;
+/** Borrow-side description. */
+declare function borrowDescription(b: BorrowTermSheet): string;
+
+declare const TERM_PROFILES: TermProfile[];
+declare function getTermProfile(id: string): TermProfile | undefined;
+/** Fallback used when a family has no dedicated profile yet. */
+declare const DEFAULT_PROFILE_ID = "pool.variable@v1";
+
+/**
+ * Stamping — the single place term sheets are attached.
+ *
+ * Runs ONCE at the end of the public-data pipeline rather than inside each
+ * lender's converter. That is the whole architecture: ~200 Aave/Compound forks
+ * get correct sheets from the generic builder with zero per-fork work, and
+ * only the ~13 exotic families need an adapter.
+ */
+interface StampOptions {
+    /** Unix seconds; injected so tests are deterministic. */
+    now?: number;
+    /** Attach ranked `implications[]` from the severity model. Default true. */
+    withImplications?: boolean;
+    /**
+     * Derive `governance` / `oracle` / exposure quality from the rows' own
+     * `oracleInfo` + `risk.breakdown`. Default true — set `false` only to test
+     * the un-enriched builder in isolation.
+     */
+    enrich?: boolean;
+}
+/**
+ * Build sheets for one lender's rows on one chain.
+ *
+ * Siblings matter: the exposure set (`backedBy` / `acceptedCollateral`) is
+ * derived by cross-referencing the OTHER rows of the same lender, so the whole
+ * group has to be built together.
+ */
+declare function buildTermSheetsForGroup(rows: Record<string, any>[], ctx?: {
+    lender?: string;
+    chainId?: string;
+    market?: Record<string, any>;
+    /** Item-level `fixedTerm` from `/lending/latest` — see `toTermSheetInput`. */
+    fixedTerm?: Record<string, any>;
+}, opts?: StampOptions): Map<string, TermSheet>;
+/**
+ * Fill `info.implications[]` from the severity model, most severe first.
+ *
+ * Derived rather than hand-written, so a newly integrated lender gets correct
+ * warnings the moment its adapter sets the right structured fields — and a
+ * warning can never contradict the numbers next to it.
+ */
+declare function attachImplications(sheet: TermSheet): TermSheet;
+/**
+ * Build an {@link EnrichmentIndex} from the market rows themselves.
+ *
+ * The governance and oracle screens are NOT a separate fetch: the origin
+ * already ships both on every row — `oracleInfo.feeds[]` (the oracle-risk
+ * classification) and `risk.breakdown[]` (the governance screen under
+ * `category: 'governance'`, the asset screen under `category: 'token'`). So
+ * the join is local to the group being stamped, with no extra round-trip and
+ * no cross-service dependency.
+ *
+ * The per-exposure enrichment falls out of the same data: an exposure item
+ * points at a SIBLING row's `marketUid`, and that sibling is already in this
+ * group — so its oracle and its asset quality are right there.
+ */
+declare function enrichmentIndexFromRows(rows: Record<string, any>[]): EnrichmentIndex;
+/**
+ * Collapse a sheet to its digest form (`?terms=digest`).
+ *
+ * Drops `items[]` from the exposure sets and the long prose — an Aave market
+ * with 30 accepted collaterals is several kB on its own, and it is the SAME
+ * accepted set repeated on every row of that lender. Every dropped item is
+ * still reachable: each carries a `marketUid` for the bulk endpoint.
+ */
+declare function toDigest(sheet: TermSheet): TermSheetDigest;
+/** Row shape of `~/risk-data/data/oracles/oracle-risk-flat.json`. */
+interface OracleRiskRow {
+    marketUid: string;
+    oracle?: string;
+    provider?: string;
+    priceDescription?: string;
+    intendedPair?: string;
+    correctOracle?: boolean | null;
+    denominatorMatch?: boolean | null;
+    fixedRate?: boolean;
+    score?: number;
+    band?: string;
+    flags?: string[];
+    /** Underlying feeds when an adapter composes several. `oracle` stays the
+     *  single source of truth — this is for auditability only. */
+    components?: string[];
+}
+/** Row shape of `~/risk-data/data/lending/market-governance-flat.json`. */
+interface GovernanceRow {
+    marketUid: string;
+    tier?: string;
+    score?: number;
+    ownerKind?: string;
+    signerThreshold?: number | null;
+    signerCount?: number | null;
+    mode?: string;
+    /** Present once the flat builder carries it through (see TERM_SHEET_PLAN §5.4.1). */
+    delaySeconds?: number | null;
+}
+/** Per-asset quality, keyed `chainId → lowercased address`. */
+type AssetRiskIndex = Record<string, Record<string, {
+    riskScore?: number;
+    source?: string;
+    liquidityUsd?: number;
+    governanceScore?: number;
+    governanceLevel?: string;
+    upgradeable?: boolean;
+    canPause?: boolean;
+    adminKind?: string;
+}>>;
+interface EnrichmentIndex {
+    oracleByMarketUid?: Map<string, OracleRiskRow>;
+    governanceByMarketUid?: Map<string, GovernanceRow>;
+    assetRisk?: AssetRiskIndex;
+}
+/**
+ * Merge governance / oracle / asset-quality onto a sheet at the SERVING layer.
+ *
+ * These cannot be computed in-package — they come from the risk-data
+ * screeners, which key on the same `marketUid` grammar (a dictionary lookup,
+ * not a fuzzy match). `margin-fetcher` emits the sheet with these blocks
+ * absent; the worker fills them in, exactly as it already does for
+ * `oracleInfo`.
+ */
+declare function enrichTermSheet(sheet: TermSheet, index: EnrichmentIndex): TermSheet;
+
+/**
+ * Invariant checker — pure, and the mechanism that turns a derivation bug into
+ * a loud failure instead of a plausible-looking wrong answer.
+ *
+ * Run over live fetched data in CI for every lender key and vault provider.
+ * Every rule here encodes something that WOULD otherwise ship silently.
+ */
+interface TermSheetViolation {
+    /** Stable slug, so a test can assert on the specific rule. */
+    rule: string;
+    message: string;
+    marketUid?: string;
+}
+declare function validateTermSheet(sheet: TermSheet): TermSheetViolation[];
+/** Validate a batch; returns every violation found, flattened. */
+declare function validateTermSheets(sheets: TermSheet[]): TermSheetViolation[];
+
+/**
+ * A term-sheet adapter: returns ONLY what the generic builder cannot derive,
+ * as a `DeepPartial<TermSheet>` merged over the generic result.
+ *
+ * Adding a lender is one adapter plus one profile entry — no core edits. The
+ * completeness test fails when a lender family reaches production without a
+ * profile, so the extension point cannot be silently skipped.
+ */
+interface TermAdapter {
+    /** Stable id, for tests and debugging. */
+    id: string;
+    /** Does this adapter handle the given lender key? */
+    matches: (lender: string) => boolean;
+    /** The profile whose prose this market points at. */
+    profileId: (input: TermSheetInput) => string;
+    build: (input: TermSheetInput) => DeepPartial<TermSheet>;
+}
+/**
+ * Order matters only where predicates could overlap; today they are disjoint.
+ * The list is walked front-to-back and the first match wins.
+ */
+declare const TERM_ADAPTERS: TermAdapter[];
+declare function resolveAdapter(lender: string): TermAdapter | undefined;
+
+export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, type AdminKind, ApiBookSource, type AprData, type AprPercent, type AssetQuality, type AssetRiskIndex, type AuctionWindow, type AvailabilityTerms, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type BorrowExitTerms, type BorrowTermSheet, type BuildTermSheetOptions, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type ConvertLenderUserDataOptions, type CoreValidators, type CounterpartyTerms, type CoverageInfo, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_PROFILE_ID, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type DeepPartial, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, EXACTLY_LENDER_KEY, type EndpointFailure, type EnrichmentIndex, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExposureEntry, type ExposureTerms, type ExtraValidationCall, type FeeTerm, type FeeWhen, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FrankencoinMarketRaw, type FrankencoinMarketsRaw, type FrankencoinPositionInfo, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GovernancePower, type GovernanceRow, type GovernanceTerms, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type IncompleteLenderRead, type IncompleteReason, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InvariantViolation, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquidationTerms, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LlamaLendMarketRaw, type LlamaLendMarketsRaw, type LlamaLendPositionInfo, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MULTICALL_FAILURE, type MaturityTerms, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type ModeVariant, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallEndpointOptions, type MulticallRpcBatch, type NumberMap, type Open, type OracleBand, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OracleRiskRow, type OracleTerms, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionKind, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PositionConstraints, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RateKind, type RateMenuEntry, type RateTerms, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type ReadFailurePolicy, type ResupplyMarketsRaw, type ResupplyPairIdentity, type ResupplyPairRaw, type ResupplyPositionInfo, type ResupplyWrappedMarket, type RewardTerm, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type Severity, type SeverityFinding, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StampOptions, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, type SupplyExitMode, type SupplyExitTerms, type SupplyTermSheet, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TERM_ADAPTERS, TERM_PROFILES, TERM_SHEET_SCHEMA_VERSION, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAdapter, type TermAssetRef, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermInfo, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, type TermProfile, type TermSheet, type TermSheetDigest, type TermSheetInput, type TermSheetViolation, TermSubgraphSource, type TermTag, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UsddMarketRaw, type UsddMarketsRaw, type UsddPositionInfo, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, type UtilizationTerms, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type ValidationResult, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachImplications, attachPricesToFlashLiquidity, borrowDescription, borrowFindings, borrowHeadline, buildExposures, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildTermSheet, buildTermSheetsForGroup, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertFrankencoinMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, deriveBorrowTags, deriveSupplyTags, detectInterfaceKinds, duration, encodeBalanceFetcherCalldata, enrichTermSheet, enrichmentIndexFromRows, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feePhrase, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchFrankencoinMarkets, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, finalizeInfo, findingsFor, frankencoinKeyParts, frankencoinLenderKey, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getReadFailurePolicy, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getTermProfile, getVaultPublicDataAll, getVaultWithdrawalRequests, hasCritical, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isFailedCall, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, mergeDeep, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, pct, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, rankFindings, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveAdapter, resolveDerivation, resolveStCeloDepositGroup, resupplyKeyParts, resupplyLenderKey, riverKeyParts, riverLenderKey, selectAssetGroupPrices, shortDate, stampVaultClassification, supplyDescription, supplyFindings, supplyHeadline, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, toDigest, toTermSheetInput, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey, validateTermSheet, validateTermSheets, validateUserData };