@kasufinance/kasu-sdk 2.13.1 → 2.15.0

package/dist/bundle.cjs.js

@@ -15502,6 +15502,185 @@ KasuPoolExternalTVLAbi__factory.abi = _abi;
 function poolTvl(onChainBalance, offChainTvl) {
     return parseFloat(onChainBalance) + parseFloat(offChainTvl);
 }
+/**
+ * What `combineTvlHistories` throws instead of returning a number it cannot
+ * stand behind. `leg` and `entry` are the zero-based position of the
+ * offending input, when there is one.
+ */
+class TvlHistoryInputError extends Error {
+    constructor(code, leg, entry) {
+        const at = [
+            leg === undefined ? '' : ` at leg ${String(leg)}`,
+            entry === undefined ? '' : `, entry ${String(entry)}`,
+        ].join('');
+        super(`combineTvlHistories: input refused (${code})${at}`);
+        this.name = 'TvlHistoryInputError';
+        this.code = code;
+        this.leg = leg;
+        this.entry = entry;
+        Object.setPrototypeOf(this, TvlHistoryInputError.prototype);
+    }
+}
+function isNonNegativeFinite(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+/**
+ * Throws unless the leg is well formed. Index loops, not `forEach`: a hole in
+ * a sparse array is skipped by the array methods and would surface later as
+ * a raw `TypeError` instead of a refusal.
+ */
+function validateLeg(leg, legIndex) {
+    if (typeof leg !== 'object' || leg === null) {
+        throw new TvlHistoryInputError('leg', legIndex);
+    }
+    const { entries, usdRate, opening } = leg;
+    if (typeof usdRate !== 'number' ||
+        !Number.isFinite(usdRate) ||
+        usdRate <= 0) {
+        throw new TvlHistoryInputError('usd-rate', legIndex);
+    }
+    if (!Array.isArray(entries)) {
+        throw new TvlHistoryInputError('entries', legIndex);
+    }
+    const list = entries;
+    if (list.length === 0) {
+        throw new TvlHistoryInputError('empty-leg', legIndex);
+    }
+    let previous = -Infinity;
+    for (let index = 0; index < list.length; index += 1) {
+        const entry = list[index];
+        if (typeof entry !== 'object' || entry === null) {
+            throw new TvlHistoryInputError('entry', legIndex, index);
+        }
+        const { timestamp, tvl, kind } = entry;
+        if (!isNonNegativeFinite(timestamp)) {
+            throw new TvlHistoryInputError('timestamp', legIndex, index);
+        }
+        if (!isNonNegativeFinite(tvl)) {
+            throw new TvlHistoryInputError('tvl', legIndex, index);
+        }
+        if (kind !== 'clearing' && kind !== 'current') {
+            throw new TvlHistoryInputError('kind', legIndex, index);
+        }
+        if (kind === 'current' && index !== list.length - 1) {
+            throw new TvlHistoryInputError('current', legIndex, index);
+        }
+        if (timestamp < previous) {
+            throw new TvlHistoryInputError('order', legIndex, index);
+        }
+        previous = timestamp;
+    }
+    if (opening !== undefined && opening !== null) {
+        const first = list[0];
+        const { timestamp, tvl, kind } = (typeof opening === 'object' ? opening : {});
+        if (!isNonNegativeFinite(timestamp) ||
+            !isNonNegativeFinite(tvl) ||
+            kind !== 'clearing' ||
+            timestamp > first.timestamp) {
+            throw new TvlHistoryInputError('opening', legIndex);
+        }
+    }
+    return leg;
+}
+/**
+ * A strategy's TVL in USD over time, from its deployments' histories — Tax
+ * Pay runs on Base (USDC) and on XDC (AUDD), and its total lent is both.
+ * Pure: the caller fetches each leg (`strategyDeployments` names them) and
+ * passes the exchange rates.
+ *
+ * A step merge by time. At every distinct timestamp where any leg has a
+ * clearing, the value is the sum over legs of that leg's latest point at or
+ * before then, times its `usdRate`. A leg's `opening` — what it held just
+ * before the window — is one more step: it counts from its own timestamp
+ * until the leg's first entry, and the leg is 0 before it (or throughout,
+ * before its first entry, without one).
+ * Points that share a timestamp — clearings run in one block, or two chains
+ * clearing in the same second — are one output point. The series ends with
+ * one `current` point at the latest of the legs' `current` timestamps, equal
+ * to the sum of their `current` values. Every leg must end in a `current`
+ * point, or none may.
+ *
+ * The window is the union of the legs' windows: the series starts at the
+ * earliest first entry of any leg. An `opening` is a value, never a point.
+ * Without it, two windows cut at offset clearing times would count the
+ * later-starting leg 0 at the left edge and draw a false step up; with it,
+ * only a genuine late start (`opening: null`) counts 0.
+ *
+ * Every leg and entry is validated first: a bad input — an empty leg
+ * included — throws `TvlHistoryInputError` (its `code` says why), so the
+ * result never holds `NaN` or `Infinity`. The inputs are not modified.
+ *
+ * ```ts
+ * const window = { count: 52 };
+ * const points = combineTvlHistories([
+ *     { ...(await base.strategies.getPoolTvlHistoryWindow(basePool, window)), usdRate: 1 },
+ *     { ...(await xdc.strategies.getPoolTvlHistoryWindow(xdcPool, window)), usdRate: audToUsd },
+ * ]);
+ * ```
+ */
+function combineTvlHistories(legs) {
+    if (!Array.isArray(legs) || legs.length === 0) {
+        throw new TvlHistoryInputError('legs');
+    }
+    const valid = [];
+    for (let index = 0; index < legs.length; index += 1) {
+        valid.push(validateLeg(legs[index], index));
+    }
+    const endsInCurrent = valid.map((leg) => leg.entries[leg.entries.length - 1].kind === 'current');
+    const odd = endsInCurrent.findIndex((ends) => ends !== endsInCurrent[0]);
+    if (odd !== -1)
+        throw new TvlHistoryInputError('current', odd);
+    const finalTimestamp = endsInCurrent[0]
+        ? Math.max(...valid.map((leg) => leg.entries[leg.entries.length - 1].timestamp))
+        : undefined;
+    const clearingTimes = [
+        ...new Set(valid.flatMap((leg) => leg.entries
+            .filter((entry) => entry.kind === 'clearing')
+            .map((entry) => entry.timestamp))),
+    ]
+        .filter((t) => finalTimestamp === undefined || t < finalTimestamp)
+        .sort((a, b) => a - b);
+    // One cursor per leg: the times ascend, so each leg is walked once. A
+    // leg's `current` point is a step like any other, which keeps a chain
+    // whose subgraph lags behind the other's last clearing at its own latest.
+    const cursors = valid.map(() => -1);
+    const sumAt = (t) => {
+        let sum = 0;
+        valid.forEach((leg, index) => {
+            let cursor = cursors[index];
+            while (cursor + 1 < leg.entries.length &&
+                leg.entries[cursor + 1].timestamp <= t) {
+                cursor += 1;
+            }
+            cursors[index] = cursor;
+            // Before the first entry, the opening is the step — from its
+            // own time on, never earlier.
+            const opening = leg.opening;
+            const value = cursor >= 0
+                ? leg.entries[cursor].tvl
+                : opening && opening.timestamp <= t
+                    ? opening.tvl
+                    : 0;
+            sum += value * leg.usdRate;
+        });
+        if (!Number.isFinite(sum))
+            throw new TvlHistoryInputError('overflow');
+        return sum;
+    };
+    const combined = clearingTimes.map((t) => ({
+        timestamp: t,
+        tvlUsd: sumAt(t),
+        kind: 'clearing',
+    }));
+    if (finalTimestamp !== undefined) {
+        combined.push({
+            timestamp: finalTimestamp,
+            tvlUsd: sumAt(finalTimestamp),
+            kind: 'current',
+        });
+    }
+    return combined;
+}
 
 /**
  * Epochs in a year — the single source of truth for every rate conversion in
@@ -16250,6 +16429,95 @@ function fetchPoolClearings(request, poolId, scope, cancellation) {
         return { clearings, snapshot, requests };
     });
 }
+/**
+ * Pure: the opening clearing — the newest of `before` (finished clearings the
+ * window left out, older by epoch) that finished STRICTLY before the first
+ * in-window clearing's block. Newest by block, then epoch, so a clearing
+ * numbered out of order (XDC AUDD's epoch 1, a week before epoch 88) is
+ * placed by when it happened. A clearing in the first in-window block itself
+ * (a catch-up block that finished several epochs at once) is not an opening:
+ * it holds the first entry's own value, not the one before it. `null` when
+ * there is none — see `needsClearingBeforeBlock`.
+ */
+function pickOpeningClearing(before, inWindow) {
+    const firstBlock = Math.min(...inWindow.map((c) => c.block));
+    let opening = null;
+    for (const clearing of before) {
+        if (clearing.block >= firstBlock)
+            continue;
+        if (opening === null ||
+            clearing.block > opening.block ||
+            (clearing.block === opening.block &&
+                clearing.epochId > opening.epochId)) {
+            opening = clearing;
+        }
+    }
+    return opening;
+}
+/**
+ * Pure: whether the opening needs `fetchClearingBefore`'s by-block read.
+ * Only when the window left clearings out but every one of them finished in
+ * or after the first in-window block — the extra rows sat in a catch-up
+ * block — so an older one, if any, was not fetched. Otherwise the opening
+ * (or its absence) is already known and nothing more is read.
+ */
+function needsClearingBeforeBlock(before, opening) {
+    return opening === null && before.length > 0;
+}
+/**
+ * The newest finished clearing in a block below `blockLt`, by block: the
+ * opening when every clearing the window left out shares its first block.
+ * ONE extra request for one row, no snapshot. Clearings that share that
+ * older block share its time and balance, so which one comes back does not
+ * change the value.
+ */
+const poolTvlClearingBeforeBlockQuery = gql `
+    query PoolTvlClearingBeforeBlock($pool: String!, $blockLt: BigInt!) {
+        clearings: lendingPoolClearings(
+            first: 1
+            orderBy: endBlockNumber
+            orderDirection: desc
+            where: {
+                lendingPool: $pool
+                isFinished: true
+                endBlockNumber_lt: $blockLt
+            }
+        ) {
+            epochId
+            endBlockNumber
+            endTimestamp
+        }
+    }
+`;
+function fetchClearingBeforeBlock(request, poolId, blockLt, cancellation) {
+    return __awaiter(this, void 0, void 0, function* () {
+        cancellation.throwIfCancelled();
+        const page = yield request(poolTvlClearingBeforeBlockQuery, { pool: poolId, blockLt: String(blockLt) }, cancellation.signal);
+        const row = page.clearings.at(0);
+        return row === undefined ? null : parseClearing(row);
+    });
+}
+/**
+ * The newest finished clearing numbered below `beforeEpoch`: the opening
+ * candidate of a `fromEpoch` window, whose own fetch never reads that far
+ * back. ONE extra request for one row, no snapshot.
+ */
+function fetchClearingBefore(request, poolId, beforeEpoch, cancellation) {
+    return __awaiter(this, void 0, void 0, function* () {
+        cancellation.throwIfCancelled();
+        const page = yield request(poolTvlClearingsQuery, {
+            poolId,
+            pool: poolId,
+            epochGte: '0',
+            epochLt: String(beforeEpoch),
+            direction: 'desc',
+            first: 1,
+            withSnapshot: false,
+        }, cancellation.signal);
+        const row = page.clearings.at(0);
+        return row === undefined ? null : parseClearing(row);
+    });
+}
 /**
  * The pool's balance (display units, the subgraph's decimal string) at the end
  * of each block, `TVL_HISTORY_BLOCKS_PER_REQUEST` blocks per request. A block
@@ -16653,6 +16921,42 @@ class DataService {
      */
     getPoolTvlHistory(poolId_1) {
         return __awaiter(this, arguments, void 0, function* (poolId, options = {}) {
+            return (yield this._poolTvlHistory(poolId, options, false)).entries;
+        });
+    }
+    /**
+     * `getPoolTvlHistory` — the same options, errors and `entries` — plus
+     * `opening`: the pool's value just before the window, so a strategy
+     * summed across deployments (`combineTvlHistories`) knows what each leg
+     * held before its first point instead of counting it 0.
+     *
+     * `opening` is the newest finished clearing STRICTLY before the window's
+     * first block (by `pickOpeningClearing`), read at its own block exactly
+     * like every other point and through the same past-block cache; `null`
+     * when the pool has no clearing before the window. Extra cost over
+     * `getPoolTvlHistory`:
+     *
+     * - `count` only: one more clearing row in the same request (`count + 1`,
+     *   which always reaches past the window when older history exists);
+     * - `fromEpoch` above 0: one more one-row subgraph request, in parallel
+     *   with the clearings;
+     * - only when every left-out clearing finished in the window's first
+     *   block (a catch-up block that closed several epochs at once): one
+     *   more one-row request by block (`fetchClearingBeforeBlock`), after
+     *   the clearings — the common case never makes it;
+     * - either way, the opening's block in the same batched time-travel read
+     *   and one more `externalTVLOfPool` read (cached once final).
+     *
+     * `{ entries: [], opening: null }` wherever `getPoolTvlHistory` returns
+     * `[]`.
+     */
+    getPoolTvlHistoryWindow(poolId_1) {
+        return __awaiter(this, arguments, void 0, function* (poolId, options = {}) {
+            return yield this._poolTvlHistory(poolId, options, true);
+        });
+    }
+    _poolTvlHistory(poolId, options, withOpening) {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a;
             validatePoolTvlHistoryOptions(options);
             if (!utils$2.isAddress(poolId)) {
@@ -16671,33 +16975,56 @@ class DataService {
                     rpcs,
                     cancellation,
                 })
-                : null, externalTvl !== null && externalTvl !== void 0 ? externalTvl : '', cancellation));
+                : null, externalTvl !== null && externalTvl !== void 0 ? externalTvl : '', cancellation, withOpening));
         });
     }
-    _readPoolTvlHistory(pool, options, reader, externalTvl, cancellation) {
+    _readPoolTvlHistory(pool, options, reader, externalTvl, cancellation, withOpening) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
+            const nothing = { entries: [], opening: null };
             const graph = (document, variables, signal) => this._graph.request({ document, variables, signal });
             const scope = options.fromEpoch === undefined && options.count !== undefined
-                ? { kind: 'newest', count: options.count }
+                ? {
+                    kind: 'newest',
+                    // One past the window: the opening, when there is one.
+                    count: options.count + (withOpening ? 1 : 0),
+                }
                 : { kind: 'from', fromEpoch: (_a = options.fromEpoch) !== null && _a !== void 0 ? _a : 0 };
             try {
-                const [currentEpochNumber, { clearings, snapshot }] = yield Promise.all([
+                const [currentEpochNumber, { clearings, snapshot }, before] = yield Promise.all([
                     this._systemVariablesAbi.currentEpochNumber(),
                     fetchPoolClearings(graph, pool, scope, cancellation),
+                    withOpening && scope.kind === 'from' && scope.fromEpoch > 0
+                        ? fetchClearingBefore(graph, pool, scope.fromEpoch, cancellation)
+                        : Promise.resolve(null),
                 ]);
                 const currentEpoch = currentEpochNumber.toNumber();
                 const window = resolvePoolTvlHistoryWindow(options, currentEpoch);
                 const poolNow = snapshot.pool;
                 if (!window || !poolNow)
-                    return [];
+                    return nothing;
                 const head = (_b = snapshot.meta) === null || _b === void 0 ? void 0 : _b.block;
                 if (!head || typeof head.timestamp !== 'number') {
                     throw new Error('getPoolTvlHistory: the subgraph returned no latest block time');
                 }
                 const inWindow = clearings.filter((c) => c.epochId >= window.fromEpoch &&
                     c.epochId <= window.toEpoch);
-                const blocks = distinctBlocks(inWindow);
+                // Clearings the window left out, older by epoch: the extra row of
+                // a count fetch, or the one-row read below `fromEpoch`.
+                const older = scope.kind === 'newest'
+                    ? clearings.filter((c) => c.epochId < window.fromEpoch)
+                    : before === null
+                        ? []
+                        : [before];
+                let opening = withOpening
+                    ? pickOpeningClearing(older, inWindow)
+                    : null;
+                // The left-out clearings all sat in the first in-window block (a
+                // catch-up block): ask for the newest one before it, by block.
+                if (withOpening && needsClearingBeforeBlock(older, opening)) {
+                    opening = yield fetchClearingBeforeBlock(graph, pool, Math.min(...inWindow.map((c) => c.block)), cancellation);
+                }
+                const blocks = distinctBlocks(opening ? [...inWindow, opening] : inWindow);
                 const withCurrent = window.toEpoch >= currentEpoch;
                 const cacheable = (block) => block <= head.number - TVL_HISTORY_CACHE_DEPTH;
                 const [balances, offChainRead] = yield Promise.all([
@@ -16715,7 +17042,7 @@ class DataService {
                             latest: null,
                         },
                 ]);
-                return buildPoolTvlHistory({
+                const entries = buildPoolTvlHistory({
                     clearings: inWindow,
                     balances,
                     offChain: offChainRead.offChain,
@@ -16729,10 +17056,22 @@ class DataService {
                         : null,
                     decimals: this._kasuConfig.stableAssetDecimals,
                 });
+                // The same function as every other point, so the opening cannot
+                // be computed another way.
+                const [openingEntry] = opening
+                    ? buildPoolTvlHistory({
+                        clearings: [opening],
+                        balances,
+                        offChain: offChainRead.offChain,
+                        current: null,
+                        decimals: this._kasuConfig.stableAssetDecimals,
+                    })
+                    : [null];
+                return { entries, opening: openingEntry };
             }
             catch (error) {
                 if (isEmptyHistoryError(error, this._kasuConfig.isLiteDeployment)) {
-                    return [];
+                    return nothing;
                 }
                 throw error;
             }
@@ -25699,9 +26038,9 @@ class SponsoredCallInputError extends Error {
         Object.setPrototypeOf(this, SponsoredCallInputError.prototype);
     }
 }
-const ADDRESS_RE$2 = /^0x[0-9a-fA-F]{40}$/;
+const ADDRESS_RE$3 = /^0x[0-9a-fA-F]{40}$/;
 function assertAddress(value, code) {
-    if (typeof value !== 'string' || !ADDRESS_RE$2.test(value)) {
+    if (typeof value !== 'string' || !ADDRESS_RE$3.test(value)) {
         throw new SponsoredCallInputError(code);
     }
 }
@@ -25830,7 +26169,7 @@ function encodeStableTransfer(input) {
     };
 }
 
-const ADDRESS_RE$1 = /^0x[0-9a-fA-F]{40}$/;
+const ADDRESS_RE$2 = /^0x[0-9a-fA-F]{40}$/;
 /**
  * Encoded, ready-to-sponsor `LendingPoolManager` calls — read, then encode,
  * NEVER send. Each returns `{ kind, call }`: post `kind` and `[call]` to a
@@ -25867,13 +26206,13 @@ class CallsFacade {
     requestWithdrawal(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const { poolId, trancheId, amount, userAddress } = params;
-            if (typeof userAddress !== 'string' || !ADDRESS_RE$1.test(userAddress)) {
+            if (typeof userAddress !== 'string' || !ADDRESS_RE$2.test(userAddress)) {
                 throw new SponsoredCallInputError('user');
             }
-            if (typeof poolId !== 'string' || !ADDRESS_RE$1.test(poolId)) {
+            if (typeof poolId !== 'string' || !ADDRESS_RE$2.test(poolId)) {
                 throw new SponsoredCallInputError('pool');
             }
-            if (typeof trancheId !== 'string' || !ADDRESS_RE$1.test(trancheId)) {
+            if (typeof trancheId !== 'string' || !ADDRESS_RE$2.test(trancheId)) {
                 throw new SponsoredCallInputError('tranche');
             }
             let shares;
@@ -26525,7 +26864,7 @@ const BEFORE_EXECUTION = ENTRY_POINT_EVENTS.getEventTopic('BeforeExecution');
 const DEPOSIT_REQUESTED = PENDING_POOL_EVENTS.getEventTopic('DepositRequested');
 const ERC20$1 = IERC20MetadataAbi__factory.createInterface();
 const LENDING_POOL_MANAGER$1 = ILendingPoolManagerAbi__factory.createInterface();
-const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+const ADDRESS_RE$1 = /^0x[0-9a-fA-F]{40}$/;
 /**
  * Case-insensitive address equality; `false` for anything that is not a
  * 20-byte hex address. Checksums are not enforced — an all-lowercase address
@@ -26534,8 +26873,8 @@ const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
 function sameAddress(a, b) {
     return (typeof a === 'string' &&
         typeof b === 'string' &&
-        ADDRESS_RE.test(a) &&
-        ADDRESS_RE.test(b) &&
+        ADDRESS_RE$1.test(a) &&
+        ADDRESS_RE$1.test(b) &&
         a.toLowerCase() === b.toLowerCase());
 }
 function isHexData(value) {
@@ -26561,7 +26900,7 @@ function isCallShape(call) {
     if (call === null || typeof call !== 'object')
         return false;
     const { to, data } = call;
-    return typeof to === 'string' && ADDRESS_RE.test(to) && isHexData(data);
+    return typeof to === 'string' && ADDRESS_RE$1.test(to) && isHexData(data);
 }
 function isZeroValue(value) {
     if (value === undefined)
@@ -27539,19 +27878,30 @@ function buildLoanAgreementSignMessage(p) {
     ].join('\n');
 }
 /**
- * The legacy `/contract/generate` and `/contract/resolve` message.
+ * The legacy `/contract/generate` message.
  *
  * ⚠️ BYTE-EXACT PROTOCOL STRING. kasu-backend rebuilds it as
  * `` `I request contract content for ${address} at ${timestamp}.` `` from the
  * `address` and `timestamp` fields of the request body — so the string signed
  * and the body sent must agree exactly, INCLUDING the address casing. This
  * builder lowercases, and the request body must carry the same lowercased
- * address; that is what both apps signing this format do today.
+ * address.
  *
  * The backend takes this path whenever the four human-readable display fields
- * are absent, and documents it as permanent until the legacy app is
- * decommissioned. `/contract/resolve` has no other format — every consumer
- * signs this one to retrieve an existing agreement.
+ * are absent. Only the retired kasu-fe-next app (retired 2026-11-05) and
+ * kasu-mobile builds from before 2026-09-06 signed it; every current consumer
+ * signs `buildLoanAgreementSignMessage`. The backend keeps accepting it until
+ * no such mobile build is left in use.
+ *
+ * It is NOT the `/contract/resolve` message. Resolve has a message of its own
+ * (`Requesting contract content for {address}/{id} at {timestamp}.`), which
+ * kasu-backend rebuilds and verifies, so it does not depend on this format.
+ *
+ * @deprecated Sign the human-readable loan-agreement message
+ *   (`buildLoanAgreementSignMessage`, `contractMessage.format:
+ *   'loan-agreement'`) instead. Only the retired kasu-fe-next app and
+ *   pre-2026-09-06 kasu-mobile builds used this format; it will be removed in
+ *   the next major version.
  *
  * @param timestampMs ms-epoch, and the same value sent as the body's
  *   `timestamp`.
@@ -28970,6 +29320,381 @@ function maxNetRateCeiling(pools, feePercent) {
     return rate;
 }
 
+/**
+ * The CMS-authored figures and text a strategy's Details screen shows, read
+ * the way kasu-ui's Details tab reads them, so every app shows the same
+ * thing.
+ *
+ * Lifted from kasu-ui (`lib/details-fields.ts`, `lib/directus-text.ts` and
+ * the parsers inside `deposit-dialog/details-tab.tsx`). The rules are facts
+ * about how the CMS is authored, not presentation:
+ *
+ *   - EMPTY IS UNAUTHORED. The CMS stores an emptied field as `''`, and its
+ *     "numeric" fields arrive as a number, a numeric string, `''` or `null`.
+ *     Anything that is not real data reads as `undefined` — never a `0`, a
+ *     placeholder or a sentence of the SDK's own. A field the caller cannot
+ *     read is a row the caller omits.
+ *   - A START DATE MUST DATE. A value that is not an ISO date, or a real
+ *     calendar date, or is before 2000 or in the future, is refused: rendered
+ *     as elapsed time it would claim a history nobody authored.
+ *   - SOME FIELDS CARRY TWO LINES IN ONE STRING. Business Types and Facility
+ *     Type are a primary value and a qualifying clause; risk-item
+ *     descriptions can be numbered enumerations. Splitting them is the same
+ *     everywhere, so it lives here.
+ *
+ * Like `pickShortDescription`, this authors no string of its own: it selects,
+ * splits and trims text the CMS already holds. None of it is sanitised —
+ * render every string as text, never as HTML or markdown.
+ *
+ * Pure. No clock: the date reader takes `now` from its caller.
+ */
+// ---------------------------------------------------------------------------
+// Start dates
+// ---------------------------------------------------------------------------
+/**
+ * `YYYY-MM-DD`, optionally followed by a time part — the two shapes a CMS
+ * date column serialises to. Checked BEFORE any parse: `new Date('Jun 2024')`
+ * is a valid date in V8, so an editorial string would otherwise become a
+ * confident duration.
+ */
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})(?:[T ].*)?$/;
+/** Nothing on Kasu has a lending history from before this year. */
+const EARLIEST_YEAR = 2000;
+/**
+ * A CMS start date as its `YYYY-MM-DD` date head, or `undefined`.
+ *
+ * Accepts an ISO date, optionally with a time part (only the date head is
+ * kept — a time changes nothing at year/month granularity, and converting it
+ * through a timezone could move it a day). Refused, as `undefined`:
+ *
+ *   - anything that is not a string (or, with `unixSeconds`, a number);
+ *   - an empty or blank string (unauthored);
+ *   - a string that is not ISO-shaped (`'Jun 2024'`);
+ *   - a date that does not exist (`'2024-02-30'`, `'2024-13-01'`) — never
+ *     rolled over into the next month;
+ *   - a year before 2000;
+ *   - a date after `now` (a typo such as 2062 for 2026 — no history has
+ *     begun in the future).
+ *
+ * `now` is the caller's clock; the facade passes the current time.
+ */
+function readCmsStartDate(value, now, options = {}) {
+    let head;
+    if (typeof value === 'number' && options.unixSeconds) {
+        // `0` is formatDuration's "unset" sentinel; negatives are pre-1970.
+        if (!Number.isFinite(value) || value <= 0)
+            return undefined;
+        const date = new Date(value * 1000);
+        if (Number.isNaN(date.getTime()))
+            return undefined;
+        head = date.toISOString().slice(0, 10);
+    }
+    else if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!ISO_DATE.test(trimmed))
+            return undefined;
+        head = trimmed.slice(0, 10);
+    }
+    else {
+        return undefined;
+    }
+    const match = ISO_DATE.exec(head);
+    if (!match)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    // Round-trip through UTC: a day or month out of range comes back as a
+    // different date, which is how a non-existent date is caught.
+    const utc = new Date(Date.UTC(year, month - 1, day));
+    if (utc.getUTCFullYear() !== year ||
+        utc.getUTCMonth() !== month - 1 ||
+        utc.getUTCDate() !== day) {
+        return undefined;
+    }
+    if (year < EARLIEST_YEAR)
+        return undefined;
+    if (utc.getTime() > now.getTime())
+        return undefined;
+    return head;
+}
+/**
+ * Business Types (the CMS `industryExposure`), split into the value and its
+ * supporting clause on the FIRST newline, else the FIRST parenthesised
+ * segment (a trailing `)` dropped):
+ *
+ *   `'SMEs & Large Businesses (diversified industries – exclusions apply)'`
+ *   → `{ primary: 'SMEs & Large Businesses', detail: 'diversified industries – exclusions apply' }`
+ *
+ * A value with neither delimiter is `{ primary }` alone. `undefined` for a
+ * missing, non-string, empty or blank value.
+ *
+ * REFINED over kasu-ui: a value that OPENS with `(` would split to an empty
+ * primary there; here the whole value is the primary instead, so `primary`
+ * is never empty. No live record has that shape.
+ */
+function splitBusinessTypes(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value)
+        return undefined;
+    let primary = value;
+    let detail = '';
+    const newlineAt = value.indexOf('\n');
+    if (newlineAt !== -1) {
+        primary = value.slice(0, newlineAt).trim();
+        detail = value.slice(newlineAt + 1).trim();
+    }
+    else {
+        const parenAt = value.indexOf('(');
+        if (parenAt !== -1) {
+            primary = value.slice(0, parenAt).trim();
+            detail = value.slice(parenAt + 1).trim();
+            if (detail.endsWith(')'))
+                detail = detail.slice(0, -1).trim();
+        }
+    }
+    if (!primary)
+        return { primary: value };
+    return detail ? { primary, detail } : { primary };
+}
+/**
+ * The start of the label, or a character that is neither a word character
+ * nor a hyphen, before `revolv` — not `\b`, which treats a hyphen as a
+ * boundary, so "Non-Revolving" would match. kasu-ui writes the same rule as
+ * the lookbehind `(?<![\w-])`; this form needs no lookbehind support from the
+ * JavaScript engine.
+ */
+const REVOLVING_FACILITY = /(?:^|[^\w-])revolv\w*\b/i;
+/**
+ * Facility Type (the CMS `loanStructure`): the label on the FIRST line, and
+ * everything after the first newline as its clause, so a clause with line
+ * breaks of its own stays whole.
+ *
+ *   `'Revolving Instalment Facility\n12-24 months instalment loan, subject to annual review'`
+ *   → `{ label: 'Revolving Instalment Facility', detail: '12-24 months …', revolving: true }`
+ *
+ * `undefined` for a missing, non-string, empty or blank value. The value is
+ * trimmed first, so a leading blank line still yields a label.
+ */
+function parseFacility(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value)
+        return undefined;
+    const breakAt = value.indexOf('\n');
+    const label = (breakAt === -1 ? value : value.slice(0, breakAt)).trim();
+    const detail = breakAt === -1 ? '' : value.slice(breakAt + 1).trim();
+    const revolving = REVOLVING_FACILITY.test(label);
+    return detail ? { label, detail, revolving } : { label, revolving };
+}
+// ---------------------------------------------------------------------------
+// Risk Management
+// ---------------------------------------------------------------------------
+/**
+ * The order the Risk Management groups read in, by group name (compared
+ * trimmed, case-insensitively). The CMS returns items in authoring order,
+ * which is not this. A group not listed still appears — after these, in CMS
+ * order.
+ */
+const RISK_GROUP_ORDER = Object.freeze([
+    'Security & Recourse',
+    'Structural Controls',
+    'Financial Covenants',
+    'Reporting Covenants',
+    'Key Eligibility Criteria',
+]);
+/** Zero-width paste artifacts, which `\s` does not match. */
+const ZERO_WIDTH = /[​-‍]/g;
+/** An `N)` marker at the start, or after a `;` / `; and,` separator. */
+const HAS_ENUMERATION = /(?:^\d+\)|;\s*(?:and,?\s*)?\d+\))/;
+const ENUMERATION_SPLIT = /(?:^|\s*;\s*(?:and,?\s*)?)\d+\)\s*/;
+/** kasu-ui's stub for an unauthored description; never a clause. */
+const EMPTY_DESCRIPTION = '—';
+/**
+ * A risk-item description as the lines beneath the item's name.
+ *
+ * A numbered enumeration (`'1) Foo; and, 2) Bar'`, or one that omits its
+ * leading `1)`: `'Foo; 2) Bar'`) is one line per clause; anything else is
+ * one line. Zero-width characters are stripped first. An unauthored
+ * description is NO lines (`[]`), never a dash.
+ */
+function splitNumberedClauses(description) {
+    const raw = cleanDescription(description);
+    if (!raw)
+        return [];
+    const clauses = HAS_ENUMERATION.test(raw)
+        ? raw
+            .split(ENUMERATION_SPLIT)
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0)
+        : [raw];
+    const lines = clauses.length > 0 ? clauses : [raw];
+    return lines.filter((line) => line !== EMPTY_DESCRIPTION);
+}
+/** A description with zero-width characters stripped, trimmed; `''` when not a string. */
+function cleanDescription(description) {
+    return typeof description === 'string'
+        ? description.replace(ZERO_WIDTH, '').trim()
+        : '';
+}
+/**
+ * Risk-management items grouped by their group, the groups in
+ * `RISK_GROUP_ORDER` and, within a group, the items in CMS order.
+ *
+ * An item with no name, or no group, is left out: there is nothing to head
+ * its lines with, or no group to place it in. (The CMS joins items to groups
+ * by name, so neither occurs in live data.) No group is ever empty, so an
+ * item list with nothing usable gives `[]`.
+ */
+function groupRiskManagementItems(items) {
+    const groups = new Map();
+    for (const source of items) {
+        const name = trimmedOrUndefined(source.name);
+        const group = trimmedOrUndefined(source.group);
+        if (!name || !group)
+            continue;
+        const clauses = splitNumberedClauses(source.description);
+        // The same cleaned text the clauses come from, and only when they
+        // say something: a description of "—" or of zero-width characters
+        // alone is unauthored, so it is absent here too, never a stray dash.
+        const description = clauses.length > 0 ? cleanDescription(source.description) : '';
+        const tooltip = trimmedOrUndefined(source.tooltip);
+        const item = Object.assign(Object.assign(Object.assign({ name }, (description ? { description } : {})), { clauses }), (tooltip ? { tooltip } : {}));
+        const existing = groups.get(group);
+        if (existing)
+            existing.items.push(item);
+        else
+            groups.set(group, { group, items: [item] });
+    }
+    // Array.prototype.sort is stable, so unlisted groups keep CMS order.
+    return [...groups.values()].sort((a, b) => riskGroupRank(a.group) - riskGroupRank(b.group));
+}
+const RISK_GROUP_RANK = new Map(RISK_GROUP_ORDER.map((group, index) => [group.toLowerCase(), index]));
+function riskGroupRank(group) {
+    var _a;
+    return ((_a = RISK_GROUP_RANK.get(group.trim().toLowerCase())) !== null && _a !== void 0 ? _a : RISK_GROUP_ORDER.length);
+}
+/**
+ * The pool's security tags (the CMS `security` list), trimmed, blanks
+ * dropped. `undefined` when none remain.
+ *
+ * kasu-ui shows these under "Security Structure over End Borrowers" ONLY
+ * when the pool has no risk-management items.
+ */
+function securityStructureOf(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const tags = raw
+        .map((tag) => trimmedOrUndefined(tag))
+        .filter((tag) => tag !== undefined);
+    return tags.length > 0 ? tags : undefined;
+}
+// ---------------------------------------------------------------------------
+// Numbers
+// ---------------------------------------------------------------------------
+/**
+ * A CMS or subgraph "numeric" value as a finite number, or `undefined`. An
+ * empty or blank string is UNAUTHORED, not zero; a genuine `0` survives.
+ */
+function finiteOrUndefined(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'string') {
+        if (value.trim() === '')
+            return undefined;
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    return undefined;
+}
+/**
+ * A leg `strategyTotalsUsd` cannot place: two legs for one deployment
+ * (`duplicate-leg`, which would double-count it), or a leg for a deployment
+ * not in `expectedDeployments` (`unexpected-leg`, a pool of some other
+ * strategy). Thrown, because both are caller bugs, not data states.
+ */
+class StrategyTotalsInputError extends Error {
+    constructor(code, deployment) {
+        super(code === 'duplicate-leg'
+            ? `strategyTotalsUsd: two legs for deployment "${deployment}"`
+            : `strategyTotalsUsd: leg for deployment "${deployment}" is not in expectedDeployments`);
+        this.code = code;
+        this.deployment = deployment;
+        this.name = 'StrategyTotalsInputError';
+    }
+}
+/**
+ * Total Active Lending and Lender Interest Earned for a strategy across the
+ * deployments it lends on, in USD: each leg's native amount times that leg's
+ * own `usdRate`, summed. Tax Pay lends on Base (USDC) and XDC (AUDD);
+ * 2,567,901 AUDD is not US$2,567,901.
+ *
+ * `expectedDeployments` is every deployment the strategy has a pool on —
+ * `strategyDeployments(poolId, chain).map((d) => d.chain)` — and `legs` the
+ * ones whose pool the caller actually loaded. What is guaranteed:
+ *
+ *   - **`null` — WITHHELD** when there are no legs, or ANY leg's rate is
+ *     missing or unusable (not a finite number above 0). The total is never
+ *     built on a guessed rate, and never silently drops a loaded leg; the
+ *     caller shows the held pool's own figure, or nothing.
+ *   - **Otherwise the sum over `legs`**, with `isPartial` /
+ *     `missingDeployments` stating exactly which expected deployments it
+ *     does NOT cover. `isPartial: false` is the only case in which the
+ *     figures are the whole strategy.
+ *   - An amount that is absent or malformed contributes nothing (a real `0`
+ *     is still `0`).
+ *   - Throws `StrategyTotalsInputError` for a duplicated leg or one not in
+ *     `expectedDeployments`, before summing anything.
+ *
+ * Only these two figures are summed. The CMS-authored ones — every
+ * originator figure, `operatingSince`, the loss rates — are shared by a
+ * strategy's pools and already strategy-wide: summing them double-counts.
+ *
+ * Mirrors the money half of kasu-ui's `aggregateStrategyPools` and its
+ * withhold gate.
+ */
+function strategyTotalsUsd(legs, expectedDeployments) {
+    var _a, _b;
+    const expected = new Set(expectedDeployments);
+    const seen = new Set();
+    for (const leg of legs) {
+        if (seen.has(leg.deployment)) {
+            throw new StrategyTotalsInputError('duplicate-leg', leg.deployment);
+        }
+        if (!expected.has(leg.deployment)) {
+            throw new StrategyTotalsInputError('unexpected-leg', leg.deployment);
+        }
+        seen.add(leg.deployment);
+    }
+    if (legs.length === 0)
+        return null;
+    let totalActiveLendingUsd = 0;
+    let lenderInterestEarnedUsd = 0;
+    for (const leg of legs) {
+        const rate = leg.usdRate;
+        if (typeof rate !== 'number' || !Number.isFinite(rate) || rate <= 0) {
+            return null;
+        }
+        totalActiveLendingUsd +=
+            ((_a = finiteOrUndefined(leg.totalActiveLending)) !== null && _a !== void 0 ? _a : 0) * rate;
+        lenderInterestEarnedUsd +=
+            ((_b = finiteOrUndefined(leg.lenderInterestEarned)) !== null && _b !== void 0 ? _b : 0) * rate;
+    }
+    const missingDeployments = [...expected].filter((d) => !seen.has(d));
+    return {
+        totalActiveLendingUsd,
+        lenderInterestEarnedUsd,
+        isPartial: missingDeployments.length > 0,
+        missingDeployments,
+    };
+}
+function trimmedOrUndefined(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+
 /**
  * A strategy's SHORT blurb, as plain text: the CMS `liteDescription` first,
  * else the first paragraph of the long `description`, else nothing.
@@ -29057,10 +29782,55 @@ class StrategiesFacade {
      * Chain pool id → the pool id its CMS record is keyed by (XDC pools
      * share their Base counterpart's editorial record). Lowercase keys.
      */
-    _poolMetadataMapping = {}) {
+    _poolMetadataMapping = {}, 
+    /**
+     * The clock the CMS start dates are checked against (a date after it
+     * is refused). Injected for tests; the current time otherwise.
+     */
+    _now = () => new Date(), 
+    /**
+     * Milliseconds on a clock that only moves forward, for the shared
+     * CMS reads' 30-second lifetime — separate from `_now`, so a pinned
+     * date clock cannot keep a read alive for ever. Injected for tests;
+     * `Date.now` otherwise.
+     */
+    _memoClockMs = () => Date.now()) {
         this._dataService = _dataService;
         this._userLending = _userLending;
         this._poolMetadataMapping = _poolMetadataMapping;
+        this._now = _now;
+        this._memoClockMs = _memoClockMs;
+        /**
+         * Short-lived, per-instance memo of the two CMS-wide reads the pool
+         * getters share, so a Details screen asking for the loss rate, the risk
+         * groups and the originator together reads each collection once. Keyed
+         * by read; holds the in-flight promise, so concurrent callers share it.
+         * A REJECTED read is dropped at once, never served again — the next call
+         * retries.
+         */
+        this._cmsReads = new Map();
+    }
+    _memoCmsRead(key, read) {
+        const nowMs = this._memoClockMs();
+        const cached = this._cmsReads.get(key);
+        if (cached && cached.expiresAt > nowMs) {
+            return cached.promise;
+        }
+        const promise = read();
+        const entry = { promise, expiresAt: nowMs + CMS_READ_TTL_MS };
+        this._cmsReads.set(key, entry);
+        promise.catch(() => {
+            // Only our own entry: a newer read may have replaced it.
+            if (this._cmsReads.get(key) === entry)
+                this._cmsReads.delete(key);
+        });
+        return promise;
+    }
+    _riskManagementRecords() {
+        return this._memoCmsRead('riskManagement', () => this._dataService.getRiskManagement());
+    }
+    _originatorProfiles() {
+        return this._memoCmsRead('originatorProfiles', () => this._dataService.getPoolDelegateProfileAndHistory());
     }
     /**
      * The pool's loss rate and first-loss capital, from its CMS
@@ -29073,12 +29843,14 @@ class StrategiesFacade {
      * 0..1 fraction.
      *
      * Requires `directusUrl`; without it the call rejects with
-     * `NO_DIRECTUS_URL_MESSAGE`, like every CMS-only read.
+     * `NO_DIRECTUS_URL_MESSAGE`, like every CMS-only read. Shares its CMS
+     * read with `getRiskManagementGroups` for 30 seconds per instance; a
+     * failed read is never reused.
      */
     getRiskPerformance(poolId) {
         return __awaiter(this, void 0, void 0, function* () {
             const metadataId = this._metadataIdOf(poolId);
-            const records = yield this._dataService.getRiskManagement();
+            const records = yield this._riskManagementRecords();
             const record = records.find((r) => String(r.poolIdFK).toLowerCase() === metadataId);
             if (!record)
                 return null;
@@ -29102,16 +29874,95 @@ class StrategiesFacade {
      * deployment every profile lists no pools and this resolves `null` —
      * the same answer kasu-ui's own lookup gives there today. The metadata
      * candidate becomes live once the service resolves the mapping.
+     *
+     * Shares its reads with `getOriginatorHistory` for 30 seconds per
+     * instance; a failed read is never reused. Each call returns its own
+     * copy of the profile, so mutating it changes nothing shared.
      */
     getOriginator(poolId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const candidates = new Set([
                 poolId.toLowerCase(),
                 this._metadataIdOf(poolId),
             ]);
-            const profiles = yield this._dataService.getPoolDelegateProfileAndHistory();
-            return ((_a = profiles.find((profile) => profile.otherKASUPools.some((pool) => candidates.has(String(pool.id).toLowerCase())))) !== null && _a !== void 0 ? _a : null);
+            const profiles = yield this._originatorProfiles();
+            const profile = profiles.find((candidate) => candidate.otherKASUPools.some((pool) => candidates.has(String(pool.id).toLowerCase())));
+            // A copy: the profiles are shared between calls (see
+            // `_memoCmsRead`), so a caller sorting or editing its result must
+            // not change what the next call returns.
+            return profile
+                ? Object.assign(Object.assign({}, profile), { otherKASUPools: profile.otherKASUPools.map((pool) => (Object.assign({}, pool))) }) : null;
+        });
+    }
+    /**
+     * The credit originator's ENTIRE lending history for a pool — since when,
+     * total originated, loans outstanding, loss rate — read from the profile
+     * `getOriginator` finds, each figure validated. `null` when no profile
+     * lists the pool, or the profile authors none of the four.
+     *
+     * kasu-ui's Details tab shows these as its Credit Originator strip, and
+     * hides the strip when there is no profile. The money figures are
+     * editorial USD on every deployment: never FX-convert them. An XDC pool
+     * resolves `null` today, as it does in kasu-ui (see `getOriginator`).
+     *
+     * Requires `directusUrl`, like every CMS-only read; rejects when the
+     * read fails. Shares its reads with `getOriginator` for 30 seconds per
+     * instance; a failed read is never reused.
+     */
+    getOriginatorHistory(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const profile = yield this.getOriginator(poolId);
+            if (!profile)
+                return null;
+            const history = {};
+            const since = readCmsStartDate(profile.delegateLendingHistory, this._now(), { unixSeconds: true });
+            if (since !== undefined)
+                history.since = since;
+            const totalOriginated = finiteOrUndefined(profile.totalLoanFundsOriginated);
+            if (totalOriginated !== undefined) {
+                history.totalOriginated = totalOriginated;
+            }
+            const loansOutstanding = finiteOrUndefined(profile.loansUnderManagement);
+            if (loansOutstanding !== undefined) {
+                history.loansOutstanding = loansOutstanding;
+            }
+            const lossRate = finiteOrUndefined(profile.historicLossRate);
+            if (lossRate !== undefined)
+                history.lossRate = lossRate;
+            return Object.keys(history).length > 0 ? history : null;
+        });
+    }
+    /**
+     * The pool's Risk Management groups, from its CMS risk-management record:
+     * each group with its items (name, the pool's description of it split
+     * into lines, the shared tooltip), the groups in `RISK_GROUP_ORDER`
+     * (Security & Recourse, Structural Controls, Financial Covenants,
+     * Reporting Covenants, Key Eligibility Criteria, then any other in CMS
+     * order). See `groupRiskManagementItems`.
+     *
+     * `null` when the pool has no record, or the record has no usable item —
+     * then kasu-ui falls back to `Strategy.securityStructure`. XDC pools
+     * resolve through the metadata mapping to their Base record, like
+     * `getRiskPerformance`.
+     *
+     * REJECTS when the CMS read fails (an outage, or no `directusUrl` —
+     * `NO_DIRECTUS_URL_MESSAGE`), so a failure stays visible rather than
+     * reading as "no items". For what to SHOW, treat a rejection like `null`:
+     * fall back to `Strategy.securityStructure`, which arrives with the
+     * strategy and needs no second read.
+     *
+     * Shares its CMS read with `getRiskPerformance` for 30 seconds per
+     * instance; a failed read is never reused.
+     */
+    getRiskManagementGroups(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadataId = this._metadataIdOf(poolId);
+            const records = yield this._riskManagementRecords();
+            const record = records.find((r) => String(r.poolIdFK).toLowerCase() === metadataId);
+            if (!record || !Array.isArray(record.items))
+                return null;
+            const groups = groupRiskManagementItems(record.items);
+            return groups.length > 0 ? groups : null;
         });
     }
     _metadataIdOf(poolId) {
@@ -29190,6 +30041,26 @@ class StrategiesFacade {
             return yield this._dataService.getPoolTvlHistory(poolId, options);
         });
     }
+    /**
+     * `getPoolTvlHistory` plus `opening` — the newest clearing before the
+     * window, read at its own block like every other point, or `null` when
+     * the pool has none — from the same read. Pass the result to
+     * `combineTvlHistories` as a leg with its `usdRate`: the opening is what
+     * the leg held before its first point, so a window cut at a different
+     * time on another chain does not count it 0. Same options and errors as
+     * `getPoolTvlHistory`; the extra cost is one clearing row (or, for
+     * `fromEpoch`, one small request) and one block.
+     *
+     * ```ts
+     * const leg = await kasu.strategies.getPoolTvlHistoryWindow(poolId, { count: 52 });
+     * // { entries: PoolTvlHistoryEntry[], opening: PoolTvlHistoryEntry | null }
+     * ```
+     */
+    getPoolTvlHistoryWindow(poolId_1) {
+        return __awaiter(this, arguments, void 0, function* (poolId, options = {}) {
+            return yield this._dataService.getPoolTvlHistoryWindow(poolId, options);
+        });
+    }
     /**
      * Fetch a single strategy by pool ID. Returns `null` if not found.
      */
@@ -29265,10 +30136,39 @@ class StrategiesFacade {
             apyStructure: pool.poolApyStructure,
             thumbnailUrl: pool.thumbnailImageUrl,
             bannerUrl: pool.bannerImageUrl,
+            strategyHistory: strategyHistoryOf(pool, this._now()),
+            endBorrowers: endBorrowersOf(pool),
+            securityStructure: securityStructureOf(pool.security),
             _raw: pool,
         };
     }
 }
+/**
+ * How long a CMS-wide read is shared between the pool getters. Long enough
+ * for one screen's worth of calls, short enough that a CMS edit shows on the
+ * next visit; apps cache further on their own terms.
+ */
+const CMS_READ_TTL_MS = 30000;
+/** `Strategy.strategyHistory`: an absent figure is an absent key. */
+function strategyHistoryOf(pool, now) {
+    const history = {};
+    const since = readCmsStartDate(pool.operatingSince, now);
+    if (since !== undefined)
+        history.since = since;
+    const lenderInterestEarned = finiteOrUndefined(pool.yieldEarned);
+    if (lenderInterestEarned !== undefined) {
+        history.lenderInterestEarned = lenderInterestEarned;
+    }
+    return history;
+}
+/** Business Types and Facility Type, or `undefined` when neither is authored. */
+function endBorrowersOf(pool) {
+    const businessTypes = splitBusinessTypes(pool.industryExposure);
+    const facility = parseFacility(pool.loanStructure);
+    if (!businessTypes && !facility)
+        return undefined;
+    return Object.assign(Object.assign({}, (businessTypes ? { businessTypes } : {})), (facility ? { facility } : {}));
+}
 /**
  * A CMS text field as a string, or `undefined` when it is absent, not a
  * string, or empty (blank included) — the CMS stores an emptied field as `''`, and an empty
@@ -30019,6 +30919,102 @@ function normaliseMapping(mapping) {
     return out;
 }
 
+/** What `strategyDeployments` throws for an id it cannot place. */
+class StrategyDeploymentInputError extends Error {
+    constructor(code) {
+        super(`strategyDeployments: input refused (${code})`);
+        this.name = 'StrategyDeploymentInputError';
+        this.code = code;
+        Object.setPrototypeOf(this, StrategyDeploymentInputError.prototype);
+    }
+}
+/** The canonical deployment: its pool ids ARE the strategies' ids. */
+const CANONICAL_CHAIN = 'base';
+const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+/** The deployment's mapping with both sides lowercased; Base never has one. */
+function mappingOf(configs, chain) {
+    var _a;
+    if (chain === CANONICAL_CHAIN)
+        return [];
+    return Object.entries((_a = configs[chain].poolMetadataMapping) !== null && _a !== void 0 ? _a : {}).map(([local, canonical]) => [local.toLowerCase(), canonical.toLowerCase()]);
+}
+/**
+ * `strategyDeployments` over any configs — the export reads `CHAIN_CONFIGS`;
+ * the spec passes its own to cover shapes the built-in mapping lacks.
+ */
+function resolveStrategyDeployments(configs, poolId, chain) {
+    const id = typeof poolId === 'string' ? poolId.trim().toLowerCase() : '';
+    if (!ADDRESS_RE.test(id)) {
+        throw new StrategyDeploymentInputError('pool-id');
+    }
+    if (typeof chain !== 'string' ||
+        !Object.prototype.hasOwnProperty.call(configs, chain)) {
+        throw new StrategyDeploymentInputError('chain');
+    }
+    const chains = Object.keys(configs);
+    const mappings = chains.map((c) => [c, mappingOf(configs, c)]);
+    const isLocalElsewhere = mappings.some(([c, mapping]) => c !== chain && mapping.some(([local]) => local === id));
+    let canonical;
+    if (chain === CANONICAL_CHAIN) {
+        // A Base id is its own Base pool — unless the mapping says it is
+        // another deployment's chain-local id, which names no Base pool.
+        if (isLocalElsewhere) {
+            throw new StrategyDeploymentInputError('wrong-chain');
+        }
+        canonical = id;
+    }
+    else {
+        const own = mappingOf(configs, chain).find(([local]) => local === id);
+        if (own) {
+            canonical = own[1];
+        }
+        else {
+            const isCanonical = mappings.some(([, mapping]) => mapping.some(([, target]) => target === id));
+            if (isLocalElsewhere || isCanonical) {
+                throw new StrategyDeploymentInputError('wrong-chain');
+            }
+            // Unmapped off Base: a strategy of one on its own chain (every
+            // XDC USDC pool today). Claiming a Base counterpart would read
+            // Base with an XDC address.
+            return [{ chain, poolId: id }];
+        }
+    }
+    const found = [
+        { chain: CANONICAL_CHAIN, poolId: canonical },
+    ];
+    for (const [c, mapping] of mappings) {
+        for (const [local, target] of mapping) {
+            if (target === canonical)
+                found.push({ chain: c, poolId: local });
+        }
+    }
+    return found;
+}
+/**
+ * Every deployment a strategy has a pool on, canonical (Base) first, then the
+ * others in `CHAIN_CONFIGS` order — the legs to fetch and pass to
+ * `combineTvlHistories`. One entry for a strategy that lives on one chain
+ * only (PayFi, on Base).
+ *
+ * `chain` is the deployment `poolId` was read on — required, because an
+ * address alone does not say which chain it belongs to. From either side of
+ * a mapping the answer is the same set: Tax Pay's Base id on `'base'` and
+ * its XDC id on `'xdc'` both return both pools. An id the mapping does not
+ * know is a strategy of one on its own chain. Ids are compared
+ * case-insensitively and returned lowercase.
+ *
+ * Throws `StrategyDeploymentInputError` for a malformed id, an unknown chain,
+ * or an id the mapping places on another deployment (`'wrong-chain'`).
+ *
+ * ```ts
+ * strategyDeployments(strategy.id, 'base');
+ * // [{ chain: 'base', poolId: '0x…' }, { chain: 'xdc', poolId: '0x…' }]
+ * ```
+ */
+function strategyDeployments(poolId, chain) {
+    return resolveStrategyDeployments(CHAIN_CONFIGS, poolId, chain);
+}
+
 /** Directus instance holding Kasu's pool editorial content. */
 const DEFAULT_DIRECTUS_URL = 'https://kasu-finance.directus.app/';
 /**
@@ -30712,6 +31708,7 @@ exports.PoolTvlHistoryAbortedError = PoolTvlHistoryAbortedError;
 exports.PoolTvlHistoryTimeoutError = PoolTvlHistoryTimeoutError;
 exports.PortfolioFacade = PortfolioFacade;
 exports.READ_ONLY_MESSAGE = READ_ONLY_MESSAGE;
+exports.RISK_GROUP_ORDER = RISK_GROUP_ORDER;
 exports.RIXON_CAPITAL = RIXON_CAPITAL;
 exports.SECONDS_PER_WEEK = SECONDS_PER_WEEK;
 exports.SPONSORED_CALL_KINDS = SPONSORED_CALL_KINDS;
@@ -30719,6 +31716,9 @@ exports.SPONSORED_CALL_SELECTORS = SPONSORED_CALL_SELECTORS;
 exports.SdkConfig = SdkConfig;
 exports.SponsoredCallInputError = SponsoredCallInputError;
 exports.StrategiesFacade = StrategiesFacade;
+exports.StrategyDeploymentInputError = StrategyDeploymentInputError;
+exports.StrategyTotalsInputError = StrategyTotalsInputError;
+exports.TvlHistoryInputError = TvlHistoryInputError;
 exports.UPPER_MEZZANINE = UPPER_MEZZANINE;
 exports.WithdrawFlow = WithdrawFlow;
 exports.accruedInterest = accruedInterest;
@@ -30738,6 +31738,7 @@ exports.ceilToCents = ceilToCents;
 exports.checkBatchOutcome = checkBatchOutcome;
 exports.checkSponsoredCallOutcome = checkSponsoredCallOutcome;
 exports.classifyWalletFailure = classifyWalletFailure;
+exports.combineTvlHistories = combineTvlHistories;
 exports.compareTrancheSeniority = compareTrancheSeniority;
 exports.computeSettlementWindow = computeSettlementWindow;
 exports.countSubmissions = countSubmissions;
@@ -30765,6 +31766,7 @@ exports.getCreditOriginator = getCreditOriginator;
 exports.getInstitutionalLender = getInstitutionalLender;
 exports.getStrategyRegion = getStrategyRegion;
 exports.getTrancheDisplayName = getTrancheDisplayName;
+exports.groupRiskManagementItems = groupRiskManagementItems;
 exports.isAuMinimumExempt = isAuMinimumExempt;
 exports.isAustralianKyc = isAustralianKyc;
 exports.isBelowMinimumCapacity = isBelowMinimumCapacity;
@@ -30780,6 +31782,7 @@ exports.maxNetRateCeiling = maxNetRateCeiling;
 exports.netEffectiveApy = netEffectiveApy;
 exports.netTrancheApyBounds = netTrancheApyBounds;
 exports.nextCycleBoundary = nextCycleBoundary;
+exports.parseFacility = parseFacility;
 exports.parseFormattedMessage = parseFormattedMessage;
 exports.parseMinorUnits = parseMinorUnits;
 exports.parseTrancheBound = parseTrancheBound;
@@ -30792,9 +31795,15 @@ exports.poolTvl = poolTvl;
 exports.projectedAnnualEarnings = projectedAnnualEarnings;
 exports.proveDepositInReceipt = proveDepositInReceipt;
 exports.proveUserOperationInReceipt = proveUserOperationInReceipt;
+exports.readCmsStartDate = readCmsStartDate;
 exports.resolveBoundShortcuts = resolveBoundShortcuts;
 exports.resolveDepositBounds = resolveDepositBounds;
+exports.securityStructureOf = securityStructureOf;
 exports.selectVisiblePools = selectVisiblePools;
+exports.splitBusinessTypes = splitBusinessTypes;
+exports.splitNumberedClauses = splitNumberedClauses;
+exports.strategyDeployments = strategyDeployments;
+exports.strategyTotalsUsd = strategyTotalsUsd;
 exports.submissionEvents = submissionEvents;
 exports.submitBatch = submitBatch;
 exports.submitSponsoredCall = submitSponsoredCall;