Previous value: -"WITHDRAWALS SIMULATED AT ONE BLOCK, where the vault is a Morpho vault over $10M: `withdraw` run by eth_call as its largest depositor (nothing sent) for $1M, a tenth of the vault, the venue’s withdrawable figure and the holder’s whole position, each capped at what the holder owns. `tries[]` carries `usd`, `label`, `ok` and the contract’s revert `reason`; `says` is the report’s sentence. One holder at one block, before anybody else takes the same liquidity. Null where not simulated."New value: +"WITHDRAWALS SIMULATED AT ONE BLOCK, where the vault is a Morpho vault over $10M: `withdraw` run by eth_call as its largest depositor (nothing sent) for $1M, a tenth of the vault, the venue’s withdrawable figure and the holder’s whole position, each capped at what the holder owns. `tries[]` carries `usd`, `label`, `ok` and the contract’s revert `reason`; `says` is the report’s sentence. `maxWithdrawUsd` is the vault’s own maxWithdraw(holder) as a LIMIT and is null where that answer is not one (a 0 beside a withdrawal that passed: Morpho V2 answers 0 by design); the raw answer is `contractReportedMaxWithdrawUsd` and `maxWithdrawMeans` says which. One holder at one block, before anybody else takes the same liquidity. Null where not simulated."

Added value: +{
+  "description": "WITHDRAWALS SIMULATED AT ONE BLOCK, where the vault is a Morpho vault over $10M: `withdraw` run by eth_call as its largest depositor (nothing sent) for $1M, a tenth of the vault, the venue’s withdrawable figure and the holder’s whole position, each capped at what the holder owns. `tries[]` carries `usd`, `label`, `ok` and the contract’s revert `reason`; `says` is the report’s sentence. One holder at one block, before anybody else takes the same liquidity. Null where not simulated.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Added value: +{
+  "description": "ON A MORPHO V2 VAULT, ITS WAYS OUT AS READ: whether a liquidity adapter is set (without one an ordinary withdrawal pays from idle only), and each adapter’s forced-deallocation penalty. The report’s exit section prints the same sentence. Null where not V2 or not read.",
+  "type": [
+    "string",
+    "null"
+  ]
+}

Added value: +{
+  "description": "THE FULLY BORROWED MARKET THIS VAULT LENDS INTO, READ OVER ITS HISTORY, where it holds a tenth of itself in a Morpho market at least 99.9% borrowed: `fullThroughout` and `ceilingThroughout` from the chain at blocks about thirty days apart (supplied, borrowed, the rate model’s rate at target), and `noRepaymentSince`, when anyone last borrowed or repaid, from the venue’s transaction index. Where nobody has repaid for months on a market at the rate ceiling, a rising share price is interest booked and not paid in. `observed` and `readAs` are the report’s own sentences. Null elsewhere.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Previous value: -"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. EACH COMPONENT NAMES THE QUANTITY IT READ: `readAs` is the reading, `basis` says which column it came from and `computation` is the arithmetic in words, so a figure here can be re-derived rather than taken on trust and compared with a figure elsewhere rather than merely disagreed with. On the exit component `basis` is `declared-withdrawable` (the venue’s own exit figure, the SAME number `vault_exits.declaredWithdrawableUsd` divides), `idle-floor` (uninvested cash, a LOWER BOUND used only where the venue publishes no exit figure, and the sentence then begins \"at least\") or `queue-float` (the same cash on a vault whose exit we have READ as a queue: the arithmetic is identical and the claim is not, because nothing there can be withdrawn without first filing a request, so that sentence never says \"could be withdrawn\"). Until 2026-10-17 it read the floor unconditionally and described it as what could be withdrawn, which gave two answers to one question on 246 vaults holding $4.26bn. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"New value: +"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. QUOTE `bandCarries` RATHER THAN `band` ALONE: it is the band in one sentence with every dimension reading worse and the controller, the same clause the report’s cover prints. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. EACH COMPONENT NAMES THE QUANTITY IT READ: `readAs` is the reading, `basis` says which column it came from and `computation` is the arithmetic in words, so a figure here can be re-derived rather than taken on trust and compared with a figure elsewhere rather than merely disagreed with. On the exit component `basis` is `declared-withdrawable` (the venue’s own exit figure, the SAME number `vault_exits.declaredWithdrawableUsd` divides), `idle-floor` (uninvested cash, a LOWER BOUND used only where the venue publishes no exit figure, and the sentence then begins \"at least\") or `queue-float` (the same cash on a vault whose exit we have READ as a queue: the arithmetic is identical and the claim is not, because nothing there can be withdrawn without first filing a request, so that sentence never says \"could be withdrawn\"). Until 2026-10-17 it read the floor unconditionally and described it as what could be withdrawn, which gave two answers to one question on 246 vaults holding $4.26bn. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"

Previous value: -"Whether we still measure this vault. `state` is `measured`, or `stopped` where the one source it had has not answered for more than seven days: the figures are then the last ones measured, on `lastMeasuredAt`, and `says` names why in the sentence the vault page shows."New value: +"Whether we still measure this vault. `state` is `measured`; `late` where the capital was last read more than 36 hours ago and under a week, with `hoursSince` and `says` giving its age; or `stopped` where the one source it had has not answered for more than seven days: the figures are then the last ones measured, on `lastMeasuredAt`, and `says` names why in the sentence the vault page shows."

Added value: +{
+  "description": "WHERE A LENDING VAULT’S CAPITAL IS, the same account the report and the vault page draw: `heldUsd` splits into `lentUsd` (lent in the markets we read), `notBorrowedUsd` (supplied to them and not borrowed) and `outsideUsd` (in no market we read: may be cash or another allocation, NOT verified as cash). `venueWithdrawableUsd` is the venue’s own figure and overlaps the others: never add it to them. `residualUsd` is how far the venue’s figure misses not-borrowed plus outside. Where two readings disagree, `gapUsd` names the difference and `lentIsEstimate` is true: lent is then capped and is an estimate, not a measurement at one moment. Null where the vault lends into no market we read.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Added value: +{
+  "description": "How old the control reading behind `keys` is, by the same rule the due-diligence report and the vault page use: `state` is `fresh` within `thresholdMinutes` (a day and two hours; control is read daily), `stale` past it, so a role may have changed since, or `unavailable` where control was never read. `ageMinutes` and `says` give the age in words.",
+  "type": "object"
+}

Added value: +{
+  "description": "CAPITAL AND POSITIONS AT ONE BLOCK, on Morpho vaults over $10M: `totalUsd` (the vault’s totalAssets) against `inMarketsUsd` (its positions, interest accrued to that block as the vault accrues it) plus `lostUsd` where the vault keeps losses on its books; `gapUsd` is what the positions do not explain at that moment and `reconciles` is true within a millionth. It confirms agreement at that block and nothing about readings taken at other times. `idleUsd` is on the vault’s own balance and outside its total. Null where the job has not read this vault.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Added value: +{
+  "description": "Whether we still measure this vault. `state` is `measured`, or `stopped` where the one source it had has not answered for more than seven days: the figures are then the last ones measured, on `lastMeasuredAt`, and `says` names why in the sentence the vault page shows.",
+  "type": "object"
+}

Previous value: -"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND `advertisedOverTheSamePeriod` IS THE ONE TO QUOTE WHERE IT IS POPULATED: it answers what the venue was advertising WHILE the return was being earned, time-weighted over the same days, which is a different and better question than what it advertises today. `benchmark` is that rate, `ratio` is the realised divided by it, and `coversWindow` says how much of the period the quotes reach. READ `excluded`: quotes whose reward composition is unread are counted there and NOT averaged in, because a share price carries the asset yield and nothing else, so a rate that may include incentives cannot be set against one. On one vault that distinction was the whole answer — 93 days of quotes were two series, 26 of ours averaging +1.12% with the composition read, and 67 backfilled from the venue averaging −0.20% with 61 negative and no reward reading at all; averaging them gave 0.17%, which is a number about neither. `benchmark` null means too little of the period is covered to average, and today’s rate is NOT a substitute — but READ `overCommonPeriod` there, which is offered exactly then: it shrinks the RETURN to the days the quotes cover so both sides span the same window, and says in its own sentence that it is the weaker of the two because a short window annualised magnifies whatever happened in it. Never both: one benchmark answering and the other explaining itself is a reading, two answering would be two numbers to choose between. No ratio is drawn where the benchmark is not positive. AND READ `sourcesDisagree` WHERE IT IS POPULATED: it says how far the venue and the aggregator are apart on the days both answer, and they are apart on every Morpho V2 vault measured — PayPal USD Main agreed on 1 of 26 days with a median gap of 0.51 percentage points, Galaxy USDC on 7 of 26 at 0.75, which on a rate near 2.85% is a fifth of the figure. Neither source is corrected into the other. \"What the venue advertises\" is not one number, and a caller comparing a realised return against an advertised rate must say which advertised rate it used. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between. AND WHERE `assetHeldShare` IS 0, READ `deployedInto` AND `deployedIntoSays`: that is where a return would have to come from, since the vault’s own price cannot carry one. `into` is the contracts it deploys into, read from the vault itself and published by no venue; `end` is how far we got — `price-moves` means the next contract IS a vault whose unit price moves, so a return is readable one level down; `price-fixed-too` means it reports as many assets as shares as well, so the flatness is not one contract’s artefact; `not-a-vault` means it answered with an interface we do not recognise, and `stoppedAt`, `implementation` and `selectors` say exactly where OUR walk ended so a caller can continue it; `attested-accounting` is the one to read on the largest of them: the contract does NOT derive what it is worth from what it holds, a multisig POSTS the figure, and `accounting` carries who may post it, when they last did, how far one posting may move it and when a posting goes stale. Those bound the POSTING and check nothing about the number, so a flat unit price upstream is not evidence that nothing was earned and a moving one would not be evidence that anything was. Its interface was resolved selector by selector against a signature database holding their preimages, which is a lookup and not a guessed ABI. `unreachable` means nothing answered, which is an endpoint and not a fact about the vault. A stopped walk is never a finding that the vault earns nothing, and `deployedIntoSays` says so in words. Null where the vault names no strategy or the walk has not run for it yet."New value: +"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND `advertisedOverTheSamePeriod` IS THE ONE TO QUOTE WHERE IT IS POPULATED: it answers what the venue was advertising WHILE the return was being earned, time-weighted over the same days, which is a different and better question than what it advertises today. `benchmark` is that rate, `ratio` is the realised divided by it, and `coversWindow` says how much of the period the quotes reach. READ `excluded`: quotes whose reward composition is unread are counted there and NOT averaged in, because a share price carries the asset yield and nothing else, so a rate that may include incentives cannot be set against one. On one vault that distinction was the whole answer — 93 days of quotes were two series, 26 of ours averaging +1.12% with the composition read, and 67 backfilled from the venue averaging −0.20% with 61 negative and no reward reading at all; averaging them gave 0.17%, which is a number about neither. `benchmark` null means too little of the period is covered to average, and today’s rate is NOT a substitute — but READ `overCommonPeriod` there, which is offered exactly then: it shrinks the RETURN to the days the quotes cover so both sides span the same window, and says in its own sentence that it is the weaker of the two because a short window annualised magnifies whatever happened in it. Never both: one benchmark answering and the other explaining itself is a reading, two answering would be two numbers to choose between. No ratio is drawn where the benchmark is not positive. AND READ `sourcesDisagree` WHERE IT IS POPULATED: it says how far the venue and the aggregator are apart on the days both answer, and they are apart on every Morpho V2 vault measured — PayPal USD Main agreed on 1 of 26 days with a median gap of 0.51 percentage points, Galaxy USDC on 7 of 26 at 0.75, which on a rate near 2.85% is a fifth of the figure. Neither source is corrected into the other. \"What the venue advertises\" is not one number, and a caller comparing a realised return against an advertised rate must say which advertised rate it used. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between. AND WHERE `assetHeldShare` IS 0, READ `deployedInto` AND `deployedIntoSays`: that is where a return would have to come from, since the vault’s own price cannot carry one. `into` is the contracts it deploys into, read from the vault itself and published by no venue; `end` is how far we got — `price-moves` means the next contract IS a vault whose unit price moves, so a return is readable one level down; `price-fixed-too` means it reports as many assets as shares as well, so the flatness is not one contract’s artefact; `not-a-vault` means it answered with an interface we do not recognise, and `stoppedAt`, `implementation` and `selectors` say exactly where OUR walk ended so a caller can continue it; `attested-accounting` is the one to read on the largest of them: the contract does NOT derive what it is worth from what it holds, a multisig POSTS the figure, and `accounting` carries who may post it, when they last did, how far one posting may move it and when a posting goes stale. Those bound the POSTING and check nothing about the number, so a flat unit price upstream is not evidence that nothing was earned and a moving one would not be evidence that anything was. Its interface was resolved selector by selector against a signature database holding their preimages, which is a lookup and not a guessed ABI. `unreachable` means nothing answered, which is an endpoint and not a fact about the vault. A stopped walk is never a finding that the vault earns nothing, and `deployedIntoSays` says so in words. Null where the vault names no strategy or the walk has not run for it yet. AND `delivery` SAYS WHICH COMPARISON THE HEADLINE RESTS ON: `basis` `same-period` (what was advertised across the window the return covers), `common-period` (both sides shrunk to the days our quotes of known composition cover, `days` says how many) or `none`, where no verdict against a promise is given and `currentQuoteContext` carries the ratio to today’s quote as context only. Quote `delivery.verdict`, not `verdict`, when saying whether a holder earned what was advertised."

Previous value: -"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. EACH COMPONENT NAMES THE QUANTITY IT READ: `readAs` is the reading, `basis` says which column it came from and `computation` is the arithmetic in words, so a figure here can be re-derived rather than taken on trust and compared with a figure elsewhere rather than merely disagreed with. On the exit component `basis` is `declared-withdrawable` (the venue’s own exit figure, the SAME number `vault_exits.declaredWithdrawableUsd` divides) or `idle-floor` (uninvested cash, a LOWER BOUND used only where the venue publishes no exit figure, and the sentence then begins \"at least\"). Until 2026-10-17 it read the floor unconditionally and described it as what could be withdrawn, which gave two answers to one question on 246 vaults holding $4.26bn. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"New value: +"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. EACH COMPONENT NAMES THE QUANTITY IT READ: `readAs` is the reading, `basis` says which column it came from and `computation` is the arithmetic in words, so a figure here can be re-derived rather than taken on trust and compared with a figure elsewhere rather than merely disagreed with. On the exit component `basis` is `declared-withdrawable` (the venue’s own exit figure, the SAME number `vault_exits.declaredWithdrawableUsd` divides), `idle-floor` (uninvested cash, a LOWER BOUND used only where the venue publishes no exit figure, and the sentence then begins \"at least\") or `queue-float` (the same cash on a vault whose exit we have READ as a queue: the arithmetic is identical and the claim is not, because nothing there can be withdrawn without first filing a request, so that sentence never says \"could be withdrawn\"). Until 2026-10-17 it read the floor unconditionally and described it as what could be withdrawn, which gave two answers to one question on 246 vaults holding $4.26bn. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"

Previous value: -"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"New value: +"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. EACH COMPONENT NAMES THE QUANTITY IT READ: `readAs` is the reading, `basis` says which column it came from and `computation` is the arithmetic in words, so a figure here can be re-derived rather than taken on trust and compared with a figure elsewhere rather than merely disagreed with. On the exit component `basis` is `declared-withdrawable` (the venue’s own exit figure, the SAME number `vault_exits.declaredWithdrawableUsd` divides) or `idle-floor` (uninvested cash, a LOWER BOUND used only where the venue publishes no exit figure, and the sentence then begins \"at least\"). Until 2026-10-17 it read the floor unconditionally and described it as what could be withdrawn, which gave two answers to one question on 246 vaults holding $4.26bn. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"

Added value: +{
+  "description": "WHO ELSE LENDS AGAINST THE SAME THING. `crowding` cannot be asked where the vault IS the lending market - in Euler’s EVK a share of its own market is 100% by construction - and this is the question those depositors do have. Each entry carries the collateral, what this vault supplied against it, how many vaults WE TRACK lend against it and what they hold between them, and `shareOfCrowd`. THE DENOMINATOR IS THE VAULTS WE TRACK and never a market: nobody publishes how much of an asset is pledged across all of lending, so this says who falls together, not how large the fall would be. A slice named `idle` is the absence of an exposure and joins no crowd. The member list is the paid half and is at /v1/collateral/{symbol}.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Added value: +{
+  "description": "WHAT DEPOSITORS ACTUALLY EARNED, on venues that publish no PnL. Hyperliquid hands us each follower’s PnL; Morpho hands us millions of equity snapshots and no PnL at all. An equity that moved is not a return - it moves because the share price moved, which is earning, and because somebody deposited or withdrew, which is not. Only intervals where a holder demonstrably neither added nor removed are attributed, and the share price move for each interval is the MEDIAN of what that vault’s own depositors did, because not one depositor snapshot shares an instant with a price reading. `measured` of `depositors`, `earnedUsd`, `spanCovered`, and the intervals DROPPED because money moved. Null where the job has not reached this vault, which is not the same as nobody earning anything.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Added value: +{
+  "description": "HOW OFTEN THE DOOR WAS SHUT, from our own daily register rather than today’s figure. `readings` is how many daily readings we hold and `firstDay`/`lastDay` the span; `lockedDays` is how many sat under 1.25% of supply withdrawable, `lockedShare` that as a fraction, `longestSpell` the longest UNBROKEN run of such readings, and `worstExitShare` the least that could ever leave. Counted in READINGS and never in calendar days: a day missing from the register is a day nobody looked, not a day the vault was fine, and the sentence says so. Under fourteen readings it describes rather than summarises, because a share over four readings is a number that looks like a record and is not one. The register has run daily since 18 August and cannot be backfilled at any price, so this answer grows more valuable and no competitor can produce it retrospectively. Null where we hold no reading for this vault, which is our record rather than a verdict on it.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Previous value: -"HOW a holder gets out, read from the vault contract, and a DIFFERENT question from how much could be withdrawn. `mechanic` is `synchronous` (a redeem settles in the transaction that asks, subject to the vault having the money — NOT a promise of an instant exit), `request-and-claim` (ERC-7540: you ask and are paid when the vault settles it, and a liquidity figure cannot answer that), or `unread` (our reading fell short, not a vault with no way out). `paused` is the contract’s own switch and is decisive when true. `feeBps` is what leaving costs, which nobody publishes beside a yield. `hours` is a notice period the contract STATES and is null where it states none — which is not zero. `queueReadable` is whether a holder can ask the contract where they stand: true where ERC-7540’s `pendingRedeemRequest` AND `claimableRedeemRequest` are both present, FALSE where a request can be filed and neither getter exists, null where there is no queue at all. Lagoon-pattern vaults carry the full set and Upshift’s carry neither, so two vaults reading `request-and-claim` can differ on the thing a holder feels most — once filed, whether anything will tell you what became of it. Found by lifting every selector out of the implementation bytecode rather than by guessing names."New value: +"HOW a holder gets out, read from the vault contract, and a DIFFERENT question from how much could be withdrawn. `mechanic` is `synchronous` (a redeem settles in the transaction that asks, subject to the vault having the money — NOT a promise of an instant exit), `request-and-claim` (ERC-7540: you ask and are paid when the vault settles it, and a liquidity figure cannot answer that), `request-via-queue` (the vault’s own teller carries no withdraw and no redeem at all: leaving means approving a SEPARATE queue contract and filing a request there for a filler to settle, so neither ERC-7540 getter is on this vault and where you stand is a question for the queue — ether.fi and Veda BoringVaults are this shape), or `unread` (our reading fell short, not a vault with no way out). `paused` is the contract’s own switch and is decisive when true. `feeBps` is what leaving costs, which nobody publishes beside a yield. `hours` is a notice period the contract STATES and is null where it states none — which is not zero. `queueReadable` is whether a holder can ask the contract where they stand: true where ERC-7540’s `pendingRedeemRequest` AND `claimableRedeemRequest` are both present, FALSE where a request can be filed and neither getter exists, null where there is no queue at all. Lagoon-pattern vaults carry the full set and Upshift’s carry neither, so two vaults reading `request-and-claim` can differ on the thing a holder feels most — once filed, whether anything will tell you what became of it. Found by lifting every selector out of the implementation bytecode rather than by guessing names."

Previous value: -"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"New value: +"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. AND READ `dimensionsWorseThanBand`: it names any dimension reading WORSE than the band, which the band itself does not show — one vault reads band `low` with market risk `severe`, and that is not an error but it does surprise. `worseThanBand` lists them, `worstDimension` is the worst any of them reads, and `says` puts it in words. Null only where the rows are withheld. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"

Previous value: -"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between. AND WHERE `assetHeldShare` IS 0, READ `deployedInto` AND `deployedIntoSays`: that is where a return would have to come from, since the vault’s own price cannot carry one. `into` is the contracts it deploys into, read from the vault itself and published by no venue; `end` is how far we got — `price-moves` means the next contract IS a vault whose unit price moves, so a return is readable one level down; `price-fixed-too` means it reports as many assets as shares as well, so the flatness is not one contract’s artefact; `not-a-vault` means it answered with an interface we do not recognise, and `stoppedAt`, `implementation` and `selectors` say exactly where OUR walk ended so a caller can continue it; `unreachable` means nothing answered, which is an endpoint and not a fact about the vault. A stopped walk is never a finding that the vault earns nothing, and `deployedIntoSays` says so in words. Null where the vault names no strategy or the walk has not run for it yet."New value: +"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND `advertisedOverTheSamePeriod` IS THE ONE TO QUOTE WHERE IT IS POPULATED: it answers what the venue was advertising WHILE the return was being earned, time-weighted over the same days, which is a different and better question than what it advertises today. `benchmark` is that rate, `ratio` is the realised divided by it, and `coversWindow` says how much of the period the quotes reach. READ `excluded`: quotes whose reward composition is unread are counted there and NOT averaged in, because a share price carries the asset yield and nothing else, so a rate that may include incentives cannot be set against one. On one vault that distinction was the whole answer — 93 days of quotes were two series, 26 of ours averaging +1.12% with the composition read, and 67 backfilled from the venue averaging −0.20% with 61 negative and no reward reading at all; averaging them gave 0.17%, which is a number about neither. `benchmark` null means too little of the period is covered to average, and today’s rate is NOT a substitute — but READ `overCommonPeriod` there, which is offered exactly then: it shrinks the RETURN to the days the quotes cover so both sides span the same window, and says in its own sentence that it is the weaker of the two because a short window annualised magnifies whatever happened in it. Never both: one benchmark answering and the other explaining itself is a reading, two answering would be two numbers to choose between. No ratio is drawn where the benchmark is not positive. AND READ `sourcesDisagree` WHERE IT IS POPULATED: it says how far the venue and the aggregator are apart on the days both answer, and they are apart on every Morpho V2 vault measured — PayPal USD Main agreed on 1 of 26 days with a median gap of 0.51 percentage points, Galaxy USDC on 7 of 26 at 0.75, which on a rate near 2.85% is a fifth of the figure. Neither source is corrected into the other. \"What the venue advertises\" is not one number, and a caller comparing a realised return against an advertised rate must say which advertised rate it used. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between. AND WHERE `assetHeldShare` IS 0, READ `deployedInto` AND `deployedIntoSays`: that is where a return would have to come from, since the vault’s own price cannot carry one. `into` is the contracts it deploys into, read from the vault itself and published by no venue; `end` is how far we got — `price-moves` means the next contract IS a vault whose unit price moves, so a return is readable one level down; `price-fixed-too` means it reports as many assets as shares as well, so the flatness is not one contract’s artefact; `not-a-vault` means it answered with an interface we do not recognise, and `stoppedAt`, `implementation` and `selectors` say exactly where OUR walk ended so a caller can continue it; `attested-accounting` is the one to read on the largest of them: the contract does NOT derive what it is worth from what it holds, a multisig POSTS the figure, and `accounting` carries who may post it, when they last did, how far one posting may move it and when a posting goes stale. Those bound the POSTING and check nothing about the number, so a flat unit price upstream is not evidence that nothing was earned and a moving one would not be evidence that anything was. Its interface was resolved selector by selector against a signature database holding their preimages, which is a lookup and not a guessed ABI. `unreachable` means nothing answered, which is an endpoint and not a fact about the vault. A stopped walk is never a finding that the vault earns nothing, and `deployedIntoSays` says so in words. Null where the vault names no strategy or the walk has not run for it yet."

Previous value: -"Who can move the money, read from the contract. `holds` is multisig, eoa, contract or timelock; `signaturesRequired` is how many a multisig needs; `actsAlone` is true where ONE party can act with no second signature, which covers a single key AND a multisig with a threshold of one — read that rather than the word multisig. `canBeHalted` is null where neither pause function answered, which may mean nobody can stop the vault or may mean its pause is behind a name we do not read — do not read a null as nobody. `notice.basis` is the field to check before trusting a delay: `measured` means we read one, `not-a-timelock` means the controller we read is not a timelock and we do not separately search for one behind it, `unread` means we did not ask. Null means we have not read this vault’s control at all, which is not the same as nobody controlling it."New value: +"Who can move the money, read from the contract. `holds` is multisig, eoa, contract or timelock; `signaturesRequired` is how many a multisig needs; `actsAlone` is true where ONE party can act with no second signature, which covers a single key AND a multisig with a threshold of one — read that rather than the word multisig. `canBeHalted` is null where neither pause function answered, which may mean nobody can stop the vault or may mean its pause is behind a name we do not read — do not read a null as nobody. `notice.basis` is the field to check before trusting a delay: `measured` means we read one on the contract, `venue-states` means the VENUE publishes a notice period and our own read of the controller found none — the figure is theirs, `statedBy` names them, and `cannotSee` says we could not confirm it, which covers 199 open vaults holding $4.99bn — `not-a-timelock` means the controller we read is not a timelock and nobody states one either, `unread` means we did not ask. A measurement always outranks a statement. Null means we have not read this vault’s control at all, which is not the same as nobody controlling it."

Added value: +{
+  "description": "WHETHER THOSE KEYS HAVE BEEN MOVING. `keys` says who controls the vault today; this says what has changed and when, which is the question an investment committee asks and a snapshot cannot answer. `changes` is newest first, each with `at`, `field`, `before`, `after` and one sentence in `says`; the fields watched are the owner key, the curator, the guardian, the authority, the proxy admin, the effective controller and its kind, the timelock delay, the multisig threshold and the pause. READ `watchedSince` BEFORE READING `count` AS A FACT ABOUT THE VAULT: a count of 0 means nothing moved since that date and NOT that the vault has never changed hands — anything earlier predates this platform holding control state and we do not reconstruct it. A failure to read a field is never filed as a removal, so `the owner key was removed` means we read an owner and then read its absence, not that an RPC timed out. Free, per vault; the population of it, every vault whose control moved this month, is on the paid screen.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Previous value: -"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between."New value: +"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between. AND WHERE `assetHeldShare` IS 0, READ `deployedInto` AND `deployedIntoSays`: that is where a return would have to come from, since the vault’s own price cannot carry one. `into` is the contracts it deploys into, read from the vault itself and published by no venue; `end` is how far we got — `price-moves` means the next contract IS a vault whose unit price moves, so a return is readable one level down; `price-fixed-too` means it reports as many assets as shares as well, so the flatness is not one contract’s artefact; `not-a-vault` means it answered with an interface we do not recognise, and `stoppedAt`, `implementation` and `selectors` say exactly where OUR walk ended so a caller can continue it; `unreachable` means nothing answered, which is an endpoint and not a fact about the vault. A stopped walk is never a finding that the vault earns nothing, and `deployedIntoSays` says so in words. Null where the vault names no strategy or the walk has not run for it yet."

Previous value: -[
-  "slug",
-  "cannotSee",
-  "says"
-]New value: +[
+  "slug",
+  "cannotSee",
+  "says",
+  "changedHands"
+]

Previous value: -"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say."New value: +"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say. `band` carries the exact boundaries behind `verdict` — below `short` of the advertised rate is short, above `beating` is beating, everything between is in-line — so a ratio of 0.70 reading `in-line` can be checked rather than guessed. AND READ `quotedOverWindow` BEFORE THE RATIO: the ratio divides a realised rate measured over `overDays` by the rate the venue quotes TODAY, which are different periods. That object holds the quotes we recorded while we watched — `mean`, `low`, `high`, `daysHeld` of `ofWindowDays`, `coversWindow`, and `quoteSits` saying whether today’s quote is `typical`, `near-its-high` or `near-its-low` for this vault. One vault read 0.70 against today’s quote and 0.996 against the average it had actually been advertising. Null where we hold fewer than five days of its quotes. AND WHERE `comparability` IS `fixed-unit-price`, READ `whyFixed` BEFORE CONCLUDING ANYTHING: `unitBasis` of `one-to-one-by-construction` means the contract reports exactly as many assets as shares, so the price CANNOT move and a flat price is the design rather than a measurement of performance — 23 of the largest 25 such vaults, holding $1.202bn across Concrete, Euler and Morpho Vaults V2, are in that state. `flat-for-another-reason` means the two are NOT equal and we have not explained it, which is published as our open question rather than left to look like a vault that earns nothing. `assetsMoved` false, with `lookbackDays`, says the vault’s own holdings did not move at all in that window. `assetHeldShare` is where the capital actually is, from `totalAssets()` against the asset token’s `balanceOf(vault)`: 1 means every unit sits in the vault as cash with nothing borrowed from it, so there is no interest to earn and the flat price is the proof; 0 means every unit is deployed somewhere else, so whatever is earned is downstream of the contract and could never show in its price. Measured over the twenty largest such vaults the split was total: eleven Euler vaults holding $212M at 1, nine Concrete and Morpho V2 vaults holding $970M at 0, nothing in between."

Previous value: -"HOW a holder gets out, read from the vault contract, and a DIFFERENT question from how much could be withdrawn. `mechanic` is `synchronous` (a redeem settles in the transaction that asks, subject to the vault having the money — NOT a promise of an instant exit), `request-and-claim` (ERC-7540: you ask and are paid when the vault settles it, and a liquidity figure cannot answer that), or `unread` (our reading fell short, not a vault with no way out). `paused` is the contract’s own switch and is decisive when true. `feeBps` is what leaving costs, which nobody publishes beside a yield. `hours` is a notice period the contract STATES and is null where it states none — which is not zero. Found by lifting every selector out of the implementation bytecode rather than by guessing names."New value: +"HOW a holder gets out, read from the vault contract, and a DIFFERENT question from how much could be withdrawn. `mechanic` is `synchronous` (a redeem settles in the transaction that asks, subject to the vault having the money — NOT a promise of an instant exit), `request-and-claim` (ERC-7540: you ask and are paid when the vault settles it, and a liquidity figure cannot answer that), or `unread` (our reading fell short, not a vault with no way out). `paused` is the contract’s own switch and is decisive when true. `feeBps` is what leaving costs, which nobody publishes beside a yield. `hours` is a notice period the contract STATES and is null where it states none — which is not zero. `queueReadable` is whether a holder can ask the contract where they stand: true where ERC-7540’s `pendingRedeemRequest` AND `claimableRedeemRequest` are both present, FALSE where a request can be filed and neither getter exists, null where there is no queue at all. Lagoon-pattern vaults carry the full set and Upshift’s carry neither, so two vaults reading `request-and-claim` can differ on the thing a holder feels most — once filed, whether anything will tell you what became of it. Found by lifting every selector out of the implementation bytecode rather than by guessing names."

Previous value: -"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"New value: +"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. `dimensions` is NULL, with `dimensionsWithheld` beside it, where this caller has read more DIFFERENT vaults in the period than the level allows — 50 a day anonymously, 500 a month with a key, 2,000 on a plan, and never counted at all on the scale plan which buys the whole surface. Nothing is slowed down and nothing else on the answer is withheld; a vault already read in the period stays open whatever the count. Past that line a caller is not checking a vault, they are reading the population, and the population is the product. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"

Previous value: -"Advertised against realised, with the ratio, the verdict, the window and its comparability. Null where we have too few price points to say."New value: +"Advertised against realised, with the ratio, the verdict and the window. TWO SEPARATE QUESTIONS live here and both must be read: `comparability` is whether the two rates can be set against each other at all, and `representativeness` is whether the result is worth planning around — `typical` where the movement is spread across the window, `event-dominated` where ONE step carries the return, `unknown` where we did not look at the shape. A vault can be `comparable` AND `event-dominated` at once: one was, with a single day accounting for 52% of the movement its return comes from, and a reader seeing only `comparable` planned around a figure that describes an event. `biggestStepShare` is that day’s share of total movement. Null where we have too few price points to say."

Added value: +{
+  "description": "How current this answer is and what it was read from: `freshness` and the ages behind it. Present on every answer from this server, whatever the tool.",
+  "type": "object"
+}

Added value: +{
+  "description": "HOW a holder gets out, read from the vault contract, and a DIFFERENT question from how much could be withdrawn. `mechanic` is `synchronous` (a redeem settles in the transaction that asks, subject to the vault having the money — NOT a promise of an instant exit), `request-and-claim` (ERC-7540: you ask and are paid when the vault settles it, and a liquidity figure cannot answer that), or `unread` (our reading fell short, not a vault with no way out). `paused` is the contract’s own switch and is decisive when true. `feeBps` is what leaving costs, which nobody publishes beside a yield. `hours` is a notice period the contract STATES and is null where it states none — which is not zero. Found by lifting every selector out of the implementation bytecode rather than by guessing names.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Previous value: -"The band, the share of components we could measure, and each applying component in its own words. READ `bandRange` BEFORE ACTING ON `band`: the score renormalises over what read, so it is what the vault scores if the unread part behaves like the read part. `bandRange` fills the unread weight with its best and its worst and names the band at each end — on one vault, moderate at 27 but anywhere from low (15) to high (60) on the 45% we cannot read. It collapses onto the band itself when every applying component was read, so a narrow range is a fact and not a formality. Null on a record not yet rescored, which `measured` tells apart from fully measured."New value: +"The band, the components it was measured from, and `dimensions`. READ `dimensions` BEFORE THE BAND. The band covers market, liquidity, concentration and operating risk and **does not contain the controller at all** — `bandCovers` says so on the object. A vault can read `low` while a single key can empty it, which is exactly what two did. Each dimension carries its own level, the components behind it, and `outsideTheBand`; `controller` and `evidence` are both outside it. A null level is UNREAD and never low. THERE IS NO OVERALL FIGURE and there will not be one: a composite would be the number every reader quotes and none can check. (This used to tell a caller to read `bandRange` first. That field is on the FULL vault document and this tool has never returned it, so the instruction could not be followed; the full document is one link away in `full`.)"

Previous value: -"object"New value: +[
+  "object",
+  "null"
+]

Added value: +{
+  "description": "Anything the server wants a caller to know about THIS answer before acting on it. Empty is the normal case and is not a guarantee.",
+  "items": {
+    "type": "string"
+  },
+  "type": "array"
+}

Previous value: -"The band, the share of components we could measure, and each applying component in its own words."New value: +"The band, the share of components we could measure, and each applying component in its own words. READ `bandRange` BEFORE ACTING ON `band`: the score renormalises over what read, so it is what the vault scores if the unread part behaves like the read part. `bandRange` fills the unread weight with its best and its worst and names the band at each end — on one vault, moderate at 27 but anywhere from low (15) to high (60) on the 45% we cannot read. It collapses onto the band itself when every applying component was read, so a narrow range is a fact and not a formality. Null on a record not yet rescored, which `measured` tells apart from fully measured."

Previous value: -"Who can move the money, read from the contract. `holds` is multisig, eoa, contract or timelock; `signaturesRequired` is how many a multisig needs; `actsAlone` is true where ONE party can act with no second signature, which covers a single key AND a multisig with a threshold of one — read that rather than the word multisig. `notice.basis` is the field to check before trusting a delay: `measured` means we read one, `not-a-timelock` means the controller we read is not a timelock and we do not separately search for one behind it, `unread` means we did not ask. Null means we have not read this vault’s control at all, which is not the same as nobody controlling it."New value: +"Who can move the money, read from the contract. `holds` is multisig, eoa, contract or timelock; `signaturesRequired` is how many a multisig needs; `actsAlone` is true where ONE party can act with no second signature, which covers a single key AND a multisig with a threshold of one — read that rather than the word multisig. `canBeHalted` is null where neither pause function answered, which may mean nobody can stop the vault or may mean its pause is behind a name we do not read — do not read a null as nobody. `notice.basis` is the field to check before trusting a delay: `measured` means we read one, `not-a-timelock` means the controller we read is not a timelock and we do not separately search for one behind it, `unread` means we did not ask. Null means we have not read this vault’s control at all, which is not the same as nobody controlling it."

Added value: +{
+  "description": "Who can move the money, read from the contract. `holds` is multisig, eoa, contract or timelock; `signaturesRequired` is how many a multisig needs; `actsAlone` is true where ONE party can act with no second signature, which covers a single key AND a multisig with a threshold of one — read that rather than the word multisig. `notice.basis` is the field to check before trusting a delay: `measured` means we read one, `not-a-timelock` means the controller we read is not a timelock and we do not separately search for one behind it, `unread` means we did not ask. Null means we have not read this vault’s control at all, which is not the same as nobody controlling it.",
+  "type": [
+    "object",
+    "null"
+  ]
+}

Added value: +"What the vault holds, in US dollars, at `capitalAsOf`. Null where we cannot price the underlying — unread, never zero."

Added value: +"The vault’s name as the venue publishes it. Their words, and two venues may use the same one."

Added value: +"The finding in one sentence. Where we cannot say what a holder earned, it says that plainly rather than reporting the venue’s own figure as ours."

Added value: +"The vault this answer is about, read back so it cannot be attached to the wrong one."