zframes 0.1.1 → 0.2.0

package/dist/index.js

@@ -101,7 +101,7 @@ var DashboardSpecSchema = z2.preprocess(
     ),
     title: z2.string().describe("Dashboard name, like package.json's name."),
     author: z2.string().optional().describe(
-      `Who made this dashboard \u2014 a free-form credit, like package.json's author ("Micky" or "Micky <pichaya@zentry.com>"). Optional.`
+      `Who made this dashboard \u2014 a free-form credit, like package.json's author ("You" or "You <you@example.com>"). Optional.`
     ),
     grid: z2.object({
       columns: z2.number().int().min(1).default(12),
@@ -154,13 +154,20 @@ var SOURCES = {
   finra: {
     name: "FINRA",
     url: "https://www.finra.org/finra-data/browse-catalog/short-sale-volume-data"
-  }
+  },
+  ofr: {
+    name: "OFR",
+    url: "https://www.financialresearch.gov/financial-stress-index/"
+  },
+  mempool: { name: "mempool.space", url: "https://mempool.space" },
+  deribit: { name: "Deribit", url: "https://www.deribit.com" },
+  coinpaprika: { name: "Coinpaprika", url: "https://coinpaprika.com" }
 };
 var clockMeta = defineFrameMeta({
   name: "clock",
   iconUrl: widgetIcon("clock"),
   layout: { w: 3, h: 2, minW: 2, minH: 1 },
-  description: "Digital clock showing the current time, ticking every second. Configurable IANA timezone (defaults to the viewer's local zone), 12/24-hour format, optional seconds and date, and a caption label. Drop several with different timezones for a trading-desk world clock. Needs no data provider.",
+  description: "Digital clock showing the current time, ticking every second. Configurable IANA timezone (defaults to the viewer's local zone), 12/24-hour format, optional seconds and date, the timezone abbreviation, and a caption label. Drop several with different timezones for a trading-desk world clock. Needs no data provider.",
   capabilities: [],
   schema: z3.object({
     timezone: z3.string().default("").describe(
@@ -174,7 +181,10 @@ var clockMeta = defineFrameMeta({
     showMillis: z3.boolean().default(false).describe(
       "Show milliseconds (HH:MM:SS.mmm), updated smoothly each animation frame. Implies seconds."
     ),
-    showDate: z3.boolean().default(false).describe("Show the weekday and date under the time.")
+    showDate: z3.boolean().default(false).describe("Show the weekday and date under the time."),
+    showTimezone: z3.boolean().default(true).describe(
+      'Show the timezone abbreviation (e.g. "EST", "GMT+7", "UTC") in the caption. Combines with the label when set, e.g. "New York \xB7 EST".'
+    )
   })
 });
 var marketHoursMeta = defineFrameMeta({
@@ -337,6 +347,58 @@ var inflationPulseMeta = defineFrameMeta({
     months: z3.number().int().min(13).max(36).default(18).describe("How many monthly CPI observations to show in the trend.")
   })
 });
+var financialStressMeta = defineFrameMeta({
+  name: "financial-stress",
+  iconUrl: widgetIcon("financial-stress"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "The OFR Financial Stress Index \u2014 a daily, market-based gauge of systemic financial stress from the U.S. Office of Financial Research. One headline value where 0 is the long-run average (positive = elevated stress, negative = calmer than normal), an optional breakdown of the five contributing categories (credit, equity valuation, safe assets, funding, volatility), and a trend line. Keyless official data, updated each business day; needs the zframes runtime's data proxy (ships with `zframes serve` / `vite dev`). Not a price feed.",
+  capabilities: ["financial-stress"],
+  source: SOURCES.ofr,
+  schema: z3.object({
+    trendDays: z3.number().int().min(20).max(90).default(60).describe("How many recent daily readings to plot in the trend line."),
+    showCategories: z3.boolean().default(true).describe(
+      "Show the five category contributions (credit, equity valuation, safe assets, funding, volatility) under the headline."
+    )
+  })
+});
+var nationalDebtMeta = defineFrameMeta({
+  name: "national-debt",
+  iconUrl: widgetIcon("national-debt"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "U.S. total public debt outstanding from the Treasury's keyless 'Debt to the Penny' dataset \u2014 the headline total in trillions, the change over the chosen window, an optional split into debt held by the public vs intragovernmental holdings, and a trend line. Official data updated each business day; CORS-safe (no proxy needed). Macro context, not a live price feed.",
+  capabilities: ["national-debt"],
+  source: SOURCES.treasury,
+  schema: z3.object({
+    trendDays: z3.number().int().min(30).max(365).default(180).describe(
+      "How many business days of history to load for the trend and the change figure."
+    ),
+    showSplit: z3.boolean().default(true).describe(
+      "Show the debt-held-by-the-public vs intragovernmental-holdings split."
+    )
+  })
+});
+var laborMarketMeta = defineFrameMeta({
+  name: "labor-market",
+  iconUrl: widgetIcon("labor-market"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "U.S. labor-market snapshot from the BLS keyless public API: the headline unemployment rate, the latest monthly change in nonfarm payrolls (jobs added or lost), the total payroll level, and an unemployment-rate trend line. Monthly macro context for stock dashboards; updates on the BLS jobs-report schedule, not a live feed.",
+  capabilities: ["macro-series"],
+  source: SOURCES.bls,
+  schema: z3.object({
+    months: z3.number().int().min(13).max(36).default(18).describe("How many monthly observations to show in the trend.")
+  })
+});
+var treasuryAuctionsMeta = defineFrameMeta({
+  name: "treasury-auctions",
+  iconUrl: widgetIcon("treasury-auctions"),
+  layout: { w: 5, h: 4, minW: 3, minH: 3 },
+  description: "Recent completed U.S. Treasury auctions from the keyless Fiscal Data API \u2014 each row shows the security (bill/note/bond + term), the high awarded yield, and the bid-to-cover ratio (demand: total bids \xF7 amount accepted; higher = stronger). Newest first. Official market-plumbing data, CORS-safe; updates as auctions settle, not a live price feed.",
+  capabilities: ["treasury-auctions"],
+  source: SOURCES.treasury,
+  schema: z3.object({
+    count: z3.number().int().min(3).max(20).default(8).describe("How many recent auctions to list (newest first).")
+  })
+});
 var filingsFeedMeta = defineFrameMeta({
   name: "filings-feed",
   iconUrl: widgetIcon("filings-feed"),
@@ -416,12 +478,12 @@ var fundingHeatmapMeta = defineFrameMeta({
   name: "funding-heatmap",
   iconUrl: widgetIcon("funding-heatmap"),
   layout: { w: 6, h: 3, minW: 4, minH: 3 },
-  description: "Heatmap of perp funding rates \u2014 symbols as rows, 4h time buckets over the last 3 days as columns, green positive / red negative. Spots persistent funding regimes at a glance.",
+  description: "Heatmap of perp funding rates \u2014 symbols as rows, daily average over the last 7 days as columns, green positive / red negative. Spots persistent funding regimes at a glance.",
   capabilities: ["funding-history"],
   source: SOURCES.hyperliquid,
   schema: z3.object({
-    symbols: z3.array(z3.string()).min(1).max(8).describe(
-      'Hyperliquid symbols as heatmap rows, e.g. ["xyz:TSLA", "xyz:NVDA", "xyz:AAPL"].'
+    symbols: z3.array(z3.string()).min(2).max(8).describe(
+      'Hyperliquid symbols as heatmap rows \u2014 at least 2, since the heatmap compares funding across symbols, e.g. ["xyz:TSLA", "xyz:NVDA", "xyz:AAPL"].'
     )
   })
 });
@@ -512,7 +574,383 @@ var allocationMeta = defineFrameMeta({
     ).min(2).max(8).describe("The holdings to chart. 2 to 8 positions.")
   })
 });
+var newsFeedMeta = defineFrameMeta({
+  name: "news-feed",
+  layout: { w: 4, h: 4, minW: 3, minH: 3 },
+  description: 'Scrolling feed of the latest news headlines from a chosen outlet \u2014 each row is a clickable headline with its publish time, newest first. Free, keyless RSS sources: crypto press (CoinDesk, Cointelegraph, Decrypt), broad markets/macro (CNBC, Nasdaq), or \u2014 source "stocks" \u2014 per-company headlines (via Google News) scoped to the specific tickers in `symbols`. IMPORTANT: news feeds are CORS-blocked, so this frame reads them through the zframes runtime\'s data proxy (it ships with `zframes serve` / `vite dev`); on a fully static host with no runtime it shows an empty state.',
+  capabilities: ["news"],
+  schema: z3.object({
+    source: z3.enum([
+      "coindesk",
+      "cointelegraph",
+      "decrypt",
+      "cnbc",
+      "nasdaq",
+      "stocks"
+    ]).default("coindesk").describe(
+      'Which feed to show. Crypto press: "coindesk", "cointelegraph", "decrypt". Markets/macro: "cnbc", "nasdaq". "stocks" = per-company headlines (Google News) for the tickers in `symbols`.'
+    ),
+    symbols: z3.array(z3.string()).default([]).describe(
+      'Only used when source is "stocks": stock tickers to pull headlines for, e.g. ["TSLA","NVDA","AAPL"]. HIP-3 symbols ("xyz:TSLA") work too \u2014 the dex prefix is stripped. Ignored for the other sources.'
+    ),
+    count: z3.number().int().min(3).max(20).default(8).describe("How many headlines to list (newest first).")
+  })
+});
+var dexVolumeTreemapMeta = defineFrameMeta({
+  name: "dex-volume-treemap",
+  layout: { w: 6, h: 4, minW: 3, minH: 3 },
+  description: "Treemap of decentralized-exchange (DEX) protocols sized by trailing-24h trading volume, tiles colored green/red by 1-day change. Data from DeFiLlama. One-glance read on where on-chain trading flow is concentrated right now.",
+  capabilities: ["dex-volume"],
+  source: SOURCES.defillama,
+  schema: z3.object({
+    topN: z3.number().int().min(3).max(30).default(12).describe("How many of the highest-volume DEX protocols to show.")
+  })
+});
+var dexVolumeChartMeta = defineFrameMeta({
+  name: "dex-volume-chart",
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Multi-series line chart of daily DEX trading volume for several protocols over a lookback window \u2014 compare how Uniswap, PancakeSwap, Aerodrome etc. trend against each other. Data from DeFiLlama (daily granularity).",
+  capabilities: ["dex-volume"],
+  source: SOURCES.defillama,
+  schema: z3.object({
+    protocols: z3.array(z3.string()).min(1).max(6).describe(
+      'DeFiLlama DEX protocol slugs (lowercase, hyphenated), e.g. ["uniswap", "pancakeswap", "aerodrome-slipstream"]. 1 to 6.'
+    ),
+    lookback: z3.enum(["7D", "1M", "3M"]).default("1M").describe("History window for the chart.")
+  })
+});
+var protocolTvlTreemapMeta = defineFrameMeta({
+  name: "protocol-tvl-treemap",
+  layout: { w: 6, h: 4, minW: 3, minH: 3 },
+  description: "Treemap of DeFi protocols sized by current total value locked (TVL), tiles colored green/red by 1-day change. Data from DeFiLlama. Unlike tvl-treemap (which groups by blockchain), this ranks individual protocols (Lido, Aave, EigenLayer\u2026).",
+  capabilities: ["protocol-tvl"],
+  source: SOURCES.defillama,
+  schema: z3.object({
+    topN: z3.number().int().min(3).max(30).default(12).describe("How many of the largest protocols by TVL to show.")
+  })
+});
+var protocolTvlChartMeta = defineFrameMeta({
+  name: "protocol-tvl-chart",
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Multi-series line chart of total value locked (TVL) for several DeFi protocols over a lookback window. Data from DeFiLlama (daily granularity).",
+  capabilities: ["protocol-tvl"],
+  source: SOURCES.defillama,
+  schema: z3.object({
+    protocols: z3.array(z3.string()).min(1).max(6).describe(
+      'DeFiLlama protocol slugs (lowercase, hyphenated), e.g. ["lido", "aave", "eigenlayer"]. 1 to 6.'
+    ),
+    lookback: z3.enum(["7D", "1M", "3M"]).default("1M").describe("History window for the chart.")
+  })
+});
+var protocolFeesTreemapMeta = defineFrameMeta({
+  name: "protocol-fees-treemap",
+  layout: { w: 6, h: 4, minW: 3, minH: 3 },
+  description: "Treemap of protocols sized by the fees they generated in the last 24h, tiles colored green/red by 1-day change. Data from DeFiLlama. Shows where on-chain users are actually paying for blockspace and services right now.",
+  capabilities: ["protocol-fees"],
+  source: SOURCES.defillama,
+  schema: z3.object({
+    topN: z3.number().int().min(3).max(30).default(12).describe("How many of the highest fee-earning protocols to show.")
+  })
+});
+var marketCapTreemapMeta = defineFrameMeta({
+  name: "market-cap-treemap",
+  layout: { w: 6, h: 4, minW: 3, minH: 3 },
+  description: "Treemap of the largest cryptocurrencies sized by market capitalisation, tiles colored green/red by 24h price change. Data from CoinGecko (free tier). A heat-map of the whole crypto market at a glance.",
+  capabilities: ["coin-markets"],
+  source: SOURCES.coingecko,
+  schema: z3.object({
+    topN: z3.number().int().min(5).max(50).default(20).describe(
+      "How many of the largest coins by market cap to show (up to 50)."
+    )
+  })
+});
+var openInterestMeta = defineFrameMeta({
+  name: "open-interest",
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: 'Live open interest across a watchlist of Hyperliquid perps \u2014 each symbol is a horizontal bar sized by USD notional, largest first, refreshed on a ~30s poll. Single-venue (Hyperliquid only), so read it as a relative gauge across your symbols, not a market-wide total. Stocks (HIP-3, e.g. "xyz:TSLA") and crypto both work.',
+  capabilities: ["open-interest"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    symbols: z3.array(z3.string()).min(1).max(20).describe(
+      `Hyperliquid symbols to compare open interest for, e.g. ["BTC", "ETH", "xyz:TSLA"]. A "<dex>:*" wildcard (e.g. "xyz:*") pulls that dex's entire universe.`
+    )
+  })
+});
+var snakeMeta = defineFrameMeta({
+  name: "snake",
+  layout: { w: 4, h: 4, minW: 3, minH: 3 },
+  description: "Classic snake game on canvas \u2014 steer with the arrow keys (or swipe), eat dots to grow, avoid the walls and your own tail. High score persists locally. For when the market is flat. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({})
+});
+var flappyBirdMeta = defineFrameMeta({
+  name: "flappy-bird",
+  layout: { w: 4, h: 4, minW: 3, minH: 3 },
+  description: "Flappy-bird style game on canvas \u2014 tap or press SPACE to flap through the gaps between pipes. High score persists locally. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({})
+});
+var videoMeta = defineFrameMeta({
+  name: "video",
+  layout: { w: 4, h: 3, minW: 2, minH: 2 },
+  description: "Embeds a video from a YouTube or Vimeo link (or any direct embed URL) as an iframe \u2014 a livestream, a market-news clip, a focus playlist. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({
+    url: z3.string().min(1).describe(
+      "Video URL \u2014 a YouTube watch/share link, a Vimeo link, or a direct embeddable URL (https)."
+    ),
+    title: z3.string().default("Video").describe("Accessible title for the embedded player (iframe title).")
+  })
+});
+var drawdyMeta = defineFrameMeta({
+  name: "drawdy",
+  layout: { w: 8, h: 6, minW: 2, minH: 2 },
+  description: "Embeds drawdy.io as an interactive whiteboard canvas. No configuration needed.",
+  capabilities: [],
+  schema: z3.object({})
+});
+var countdownMeta = defineFrameMeta({
+  name: "countdown",
+  layout: { w: 3, h: 2, minW: 2, minH: 1 },
+  description: "Live countdown to a target date and time \u2014 FOMC decisions, CPI prints, options expiry, earnings, a token unlock, the next market open. Counts down in days / hours / minutes / seconds, ticking every second, and flips to a 'reached' state once the moment passes. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({
+    target: z3.string().default("").describe(
+      `The moment to count down to, as an ISO 8601 string. Add a timezone for an unambiguous instant, e.g. "2026-07-30T18:00:00-04:00" or "2026-12-31T23:59:59Z"; a bare "2026-07-30T18:00" is read in the viewer's local timezone. Empty shows a "set a target" prompt.`
+    ),
+    label: z3.string().default("").describe(
+      'Caption above the countdown, e.g. "FOMC Decision". Empty hides it.'
+    ),
+    showTarget: z3.boolean().default(true).describe("Show the formatted target date and time under the countdown.")
+  })
+});
+var linkGridMeta = defineFrameMeta({
+  name: "link-grid",
+  layout: { w: 3, h: 2, minW: 2, minH: 1 },
+  description: "A grid of quick-launch tiles linking to your favourite sites \u2014 TradingView, exchanges, news, docs, your own dashboards. Each tile opens in a new tab and shows the destination site's favicon by default (fetched keyless from a public favicon service), with an optional per-link icon override and a first-letter fallback. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({
+    links: z3.array(
+      z3.object({
+        label: z3.string().min(1).describe('Tile caption, e.g. "TradingView".'),
+        url: z3.string().min(1).describe("Destination URL (https). Opens in a new tab."),
+        icon: z3.string().default("").describe(
+          `Optional icon override: an emoji (e.g. "\u{1F4C8}") or an https image URL. Empty uses the destination site's favicon, falling back to the label's first letter.`
+        )
+      })
+    ).min(1).default([
+      {
+        label: "TradingView",
+        url: "https://www.tradingview.com",
+        icon: "\u{1F4C8}"
+      },
+      {
+        label: "Hyperliquid",
+        url: "https://app.hyperliquid.xyz",
+        icon: "\u26A1"
+      }
+    ]).describe("The links to show as tiles. At least one."),
+    columns: z3.number().int().min(1).max(4).default(2).describe("How many tiles per row.")
+  })
+});
+var calculatorMeta = defineFrameMeta({
+  name: "calculator",
+  layout: { w: 3, h: 3, minW: 2, minH: 2 },
+  description: "Position-size & risk calculator. Enter account size, risk-per-trade %, entry and stop price; it computes the dollars at risk, the per-unit risk, the position size (units) that respects that risk budget, the resulting position value, and whether the setup is long or short. All math runs client-side \u2014 no data provider. Inputs are editable live; the configured values are the starting point.",
+  capabilities: [],
+  schema: z3.object({
+    account: z3.number().positive().default(1e4).describe("Account size used as the risk base, in the quote currency."),
+    riskPct: z3.number().positive().max(100).default(1).describe("Percent of the account risked on the trade, e.g. 1 = 1%."),
+    entry: z3.number().positive().default(100).describe("Entry price."),
+    stop: z3.number().positive().default(95).describe(
+      "Stop-loss price. Its distance from entry sets the per-unit risk; below entry = long, above = short."
+    ),
+    currency: z3.string().default("$").describe("Currency symbol shown next to money values.")
+  })
+});
+var quoteMeta = defineFrameMeta({
+  name: "quote",
+  layout: { w: 4, h: 2, minW: 2, minH: 1 },
+  description: 'Displays a market or trading quote, centered \u2014 set one or rotate through several. A calm bit of wall-art for the dashboard: trading maxims, reminders of your own rules, mantras. Write any attribution into the text itself (e.g. "\u2026 \u2014 Buffett"). Needs no data provider.',
+  capabilities: [],
+  schema: z3.object({
+    quotes: z3.array(z3.string().min(1)).min(1).default([
+      "Be fearful when others are greedy, and greedy when others are fearful. \u2014 Warren Buffett",
+      "The trend is your friend until the end when it bends.",
+      "Plan the trade, trade the plan."
+    ]).describe(
+      "One or more quotes. With more than one, the frame rotates through them."
+    ),
+    intervalSec: z3.number().int().min(0).default(12).describe(
+      "Seconds between rotations when there are multiple quotes. 0 shows the first quote, fixed."
+    )
+  })
+});
+var dividerMeta = defineFrameMeta({
+  name: "divider",
+  layout: { w: 12, h: 1, minW: 1, minH: 1 },
+  description: "A plain rule that separates regions of the dashboard, with an optional centered label. Renders chrome-less (no card) \u2014 lighter than a heading. Use a horizontal divider full-width between stacked zones, or set orientation to vertical for a 1-column-wide column separator. Needs no data provider.",
+  capabilities: [],
+  chrome: "bare",
+  schema: z3.object({
+    label: z3.string().default("").describe(
+      "Optional text shown in the middle of the rule. Empty = a clean line."
+    ),
+    orientation: z3.enum(["horizontal", "vertical"]).default("horizontal").describe(
+      "Horizontal rule (spans the width) or vertical rule (spans the height)."
+    ),
+    style: z3.enum(["solid", "dashed", "dotted"]).default("solid").describe("Line style.")
+  })
+});
+var btcFeesMeta = defineFrameMeta({
+  name: "btc-fees",
+  iconUrl: widgetIcon("btc-fees"),
+  layout: { w: 3, h: 2, minW: 2, minH: 2 },
+  description: "Recommended Bitcoin on-chain fee rates (sat/vB) from mempool.space \u2014 the next-block ('fastest'), ~30-minute, ~1-hour, economy, and minimum tiers, as a compact gauge. Live mempool data, keyless; updates every ~30s.",
+  capabilities: ["btc-fees"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    tiers: z3.array(z3.enum(["fastest", "halfHour", "hour", "economy", "minimum"])).min(1).max(5).default(["fastest", "halfHour", "hour", "economy"]).describe(
+      'Which fee tiers to show, in order. "fastest" = next block, "halfHour"/"hour" = within ~30/60 min, "economy"/"minimum" = cheapest relayable.'
+    )
+  })
+});
+var btcMempoolMeta = defineFrameMeta({
+  name: "btc-mempool",
+  iconUrl: widgetIcon("btc-mempool"),
+  layout: { w: 5, h: 3, minW: 3, minH: 2 },
+  description: "Bitcoin mempool congestion at a glance \u2014 unconfirmed transaction count, total pending vsize, and a row of projected ('template') blocks the network will likely mine next, each labelled with its median fee rate (sat/vB) and tx count. Live mempool data from mempool.space, keyless.",
+  capabilities: ["btc-mempool"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    projectedBlocks: z3.number().int().min(1).max(8).default(5).describe(
+      "How many projected (yet-to-be-mined) blocks to show, next-to-mine first."
+    )
+  })
+});
+var btcBlocksMeta = defineFrameMeta({
+  name: "btc-blocks",
+  iconUrl: widgetIcon("btc-blocks"),
+  layout: { w: 5, h: 4, minW: 3, minH: 3 },
+  description: "Feed of the most recently mined Bitcoin blocks \u2014 each row shows the height, how long ago it was mined, transaction count, the mining pool that found it, total fees (BTC), and size. Live data from mempool.space, keyless; newest first.",
+  capabilities: ["btc-blocks"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    count: z3.number().int().min(3).max(15).default(8).describe("How many recent blocks to list (newest first).")
+  })
+});
+var btcHashrateMeta = defineFrameMeta({
+  name: "btc-hashrate",
+  iconUrl: widgetIcon("btc-hashrate"),
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Bitcoin network hashrate over time as a line chart, with the current hashrate (EH/s) and difficulty as headline figures. Shows the long-run security trend of the network. Data from mempool.space (daily granularity), keyless.",
+  capabilities: ["btc-hashrate"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    window: z3.enum(["1y", "2y", "3y"]).default("1y").describe("History window for the hashrate line.")
+  })
+});
+var btcDifficultyMeta = defineFrameMeta({
+  name: "btc-difficulty",
+  iconUrl: widgetIcon("btc-difficulty"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "Countdown to the next Bitcoin difficulty adjustment \u2014 a progress bar through the current 2016-block epoch, the estimated change (+ = mining gets harder), blocks remaining, and the estimated retarget date. Also shows the previous adjustment. Data from mempool.space, keyless.",
+  capabilities: ["btc-difficulty"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    showPrevious: z3.boolean().default(true).describe(
+      "Also show the percentage change applied at the previous retarget."
+    )
+  })
+});
+var miningPoolsMeta = defineFrameMeta({
+  name: "mining-pools",
+  iconUrl: widgetIcon("mining-pools"),
+  layout: { w: 6, h: 4, minW: 3, minH: 3 },
+  description: "Treemap of Bitcoin mining-pool dominance over a window \u2014 each tile is a pool sized by the share of blocks it mined, so you can see how concentrated hashpower is right now (Foundry, AntPool, ViaBTC\u2026). Data from mempool.space, keyless.",
+  capabilities: ["mining-pools"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    window: z3.enum(["24h", "3d", "1w", "1m"]).default("1w").describe("Window over which to measure each pool's block share."),
+    topN: z3.number().int().min(3).max(25).default(12).describe(
+      "How many of the largest pools to show; the rest fold into 'Other'."
+    )
+  })
+});
+var lightningStatsMeta = defineFrameMeta({
+  name: "lightning-stats",
+  iconUrl: widgetIcon("lightning-stats"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "Bitcoin Lightning Network snapshot \u2014 public node count, channel count, and total network capacity (BTC), with a day-over-day delta and the Tor/clearnet node split. Data from mempool.space, keyless; updates roughly daily.",
+  capabilities: ["lightning-stats"],
+  source: SOURCES.mempool,
+  schema: z3.object({
+    showSplit: z3.boolean().default(true).describe(
+      "Show the Tor vs clearnet node split under the headline stats."
+    )
+  })
+});
+var optionsPutCallMeta = defineFrameMeta({
+  name: "options-put-call",
+  iconUrl: widgetIcon("options-put-call"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "Deribit options put/call ratio for BTC or ETH \u2014 the headline ratio (by open interest or 24h volume), a call-vs-put open-interest split bar, and the open-interest-weighted average implied volatility. A ratio above 1 means puts outweigh calls (defensive positioning). Keyless Deribit market data.",
+  capabilities: ["options-summary"],
+  source: SOURCES.deribit,
+  schema: z3.object({
+    currency: z3.enum(["BTC", "ETH"]).default("BTC").describe(
+      "Which Deribit options book to summarise \u2014 BTC or ETH (the only deeply liquid books)."
+    ),
+    basis: z3.enum(["oi", "volume"]).default("oi").describe(
+      'Headline put/call ratio basis: "oi" = by open interest (positioning), "volume" = by 24h traded volume (flow). The other is shown smaller.'
+    )
+  })
+});
+var optionsIvMeta = defineFrameMeta({
+  name: "options-iv",
+  iconUrl: widgetIcon("options-iv"),
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Deribit DVOL implied-volatility index for BTC or ETH over time \u2014 the crypto equivalent of the VIX, as a line chart with the current reading and its change over the window. Rising DVOL = the market is pricing bigger expected swings. Keyless Deribit market data.",
+  capabilities: ["volatility-index"],
+  source: SOURCES.deribit,
+  schema: z3.object({
+    currency: z3.enum(["BTC", "ETH"]).default("BTC").describe("Which DVOL volatility index to plot \u2014 BTC or ETH."),
+    lookback: z3.enum(["7D", "1M", "3M"]).default("1M").describe("History window for the volatility-index line.")
+  })
+});
+var optionsOiStrikeMeta = defineFrameMeta({
+  name: "options-oi-strike",
+  iconUrl: widgetIcon("options-oi-strike"),
+  layout: { w: 6, h: 4, minW: 4, minH: 3 },
+  description: "Open interest by strike for the nearest Deribit options expiry (BTC or ETH) \u2014 a grouped histogram of call vs put open interest across strikes, with the current spot marked. Surfaces the strike 'walls' where positioning is concentrated. Keyless Deribit market data.",
+  capabilities: ["options-summary"],
+  source: SOURCES.deribit,
+  schema: z3.object({
+    currency: z3.enum(["BTC", "ETH"]).default("BTC").describe("Which Deribit options book \u2014 BTC or ETH."),
+    strikes: z3.number().int().min(6).max(30).default(14).describe(
+      "How many strikes nearest the current spot to show (centered on the underlying price)."
+    )
+  })
+});
+var coinMoversMeta = defineFrameMeta({
+  name: "coin-movers",
+  iconUrl: widgetIcon("coin-movers"),
+  layout: { w: 5, h: 4, minW: 3, minH: 3 },
+  description: "Broad-market crypto gainers and losers across the top ~300 coins by market cap, over a selectable window (1h / 24h / 7d / 30d) \u2014 the biggest movers side by side with price and % change. Unlike a top-coins heatmap, this surfaces mid- and small-caps that ripped or dumped, not just the megacaps. Keyless data from Coinpaprika. Crypto only.",
+  capabilities: ["coin-movers"],
+  source: SOURCES.coinpaprika,
+  schema: z3.object({
+    window: z3.enum(["1h", "24h", "7d", "30d"]).default("24h").describe(
+      "Which price-change window ranks the movers: 1h (intraday momentum), 24h (daily), 7d (weekly), 30d (monthly)."
+    ),
+    count: z3.number().int().min(3).max(15).default(6).describe("How many gainers and how many losers to list (each side)."),
+    minRank: z3.number().int().min(20).max(300).default(150).describe(
+      "Only consider coins ranked at or above this market-cap rank \u2014 a liquidity floor that keeps illiquid micro-cap dust (which posts absurd % moves on no volume) out of the list. Lower = stricter (megacaps only); higher = includes more small-caps."
+    )
+  })
+});
 var frameMetas = [
+  newsFeedMeta,
   allocationMeta,
   bitcoinDominanceMeta,
   clockMeta,
@@ -521,6 +959,10 @@ var frameMetas = [
   fearGreedMeta,
   filingsFeedMeta,
   fundamentalsMeta,
+  financialStressMeta,
+  laborMarketMeta,
+  nationalDebtMeta,
+  treasuryAuctionsMeta,
   fundingHeatmapMeta,
   fundingRateChartMeta,
   headingMeta,
@@ -536,7 +978,34 @@ var frameMetas = [
   shortVolumeMeta,
   topMoversMeta,
   tvlTreemapMeta,
-  yieldCurveMeta
+  yieldCurveMeta,
+  dexVolumeTreemapMeta,
+  dexVolumeChartMeta,
+  protocolTvlTreemapMeta,
+  protocolTvlChartMeta,
+  protocolFeesTreemapMeta,
+  marketCapTreemapMeta,
+  openInterestMeta,
+  snakeMeta,
+  flappyBirdMeta,
+  videoMeta,
+  drawdyMeta,
+  countdownMeta,
+  linkGridMeta,
+  calculatorMeta,
+  quoteMeta,
+  dividerMeta,
+  btcFeesMeta,
+  btcMempoolMeta,
+  btcBlocksMeta,
+  btcHashrateMeta,
+  btcDifficultyMeta,
+  miningPoolsMeta,
+  lightningStatsMeta,
+  optionsPutCallMeta,
+  optionsIvMeta,
+  optionsOiStrikeMeta,
+  coinMoversMeta
 ];
 
 // src/init.ts
@@ -582,7 +1051,7 @@ function skeleton(title, author) {
     background: {
       type: "unicorn",
       projectId: "YrTzGatwjK7EoFpCSfgZ",
-      opacity: 0.05
+      opacity: 1
     },
     theme: { accentHue: 242, accentSat: 90 },
     appearance: {
@@ -643,17 +1112,76 @@ function init(args) {
   return 0;
 }
 
+// src/lint.ts
+function lintSpec(spec) {
+  const issues = [];
+  const metaByName = new Map(frameMetas.map((meta) => [meta.name, meta]));
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const instance of spec.frames) {
+    if (seenIds.has(instance.id))
+      issues.push({
+        frameId: instance.id,
+        message: `duplicate frame id "${instance.id}"`
+      });
+    seenIds.add(instance.id);
+    const meta = metaByName.get(instance.frame);
+    if (!meta) {
+      issues.push({
+        frameId: instance.id,
+        message: `unknown frame "${instance.frame}". available: ${[
+          ...metaByName.keys()
+        ].join(", ")}`
+      });
+      continue;
+    }
+    const parsed = meta.schema.safeParse(instance.config);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        issues.push({
+          frameId: instance.id,
+          message: `config.${issue.path.join(".") || "(root)"}: ${issue.message}`
+        });
+      }
+    }
+    if (instance.position.x + instance.position.w > spec.grid.columns)
+      issues.push({
+        frameId: instance.id,
+        message: `overflows the grid: x(${instance.position.x}) + w(${instance.position.w}) > ${spec.grid.columns} columns`
+      });
+  }
+  for (let i = 0; i < spec.frames.length; i++) {
+    for (let j = i + 1; j < spec.frames.length; j++) {
+      const a = spec.frames[i].position;
+      const b = spec.frames[j].position;
+      const overlap = a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+      if (overlap)
+        issues.push({
+          frameId: spec.frames[i].id,
+          message: `overlaps frame "${spec.frames[j].id}"`
+        });
+    }
+  }
+  return issues;
+}
+
 // src/serve.ts
-import { createReadStream, existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { createServer } from "http";
-import { extname, join as join3, resolve as resolve2, sep } from "path";
+import { join as join3, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+import sirv from "sirv";
 
 // ../core/src/serve.ts
 import { readFile, writeFile } from "fs/promises";
+
+// ../core/src/routes.ts
 var DASHBOARD_READ_ROUTE = "/__zframes/dashboard.json";
 var DASHBOARD_WRITE_ROUTE = "/__zframes/dashboard";
 var DASHBOARD_PROXY_ROUTE = "/__zframes/proxy";
+var AGENTS_LIST_ROUTE = "/__zframes/agents";
+var ASK_ROUTE = "/__zframes/ask";
+
+// ../core/src/serve.ts
 var MAX_BODY_BYTES = 2e6;
 var PROXY_ALLOW_HOSTS = /* @__PURE__ */ new Set([
   "data.sec.gov",
@@ -666,7 +1194,15 @@ var PROXY_ALLOW_HOSTS = /* @__PURE__ */ new Set([
   "markets.newyorkfed.org",
   "api.fiscaldata.treasury.gov",
   "api.bls.gov",
-  "cdn.finra.org"
+  "cdn.finra.org",
+  // News-outlet RSS feeds (CORS-blocked, so the news-feed frame reads them
+  // through here). Headlines + links only; no keys.
+  "www.coindesk.com",
+  "cointelegraph.com",
+  "decrypt.co",
+  "www.cnbc.com",
+  "www.nasdaq.com",
+  "news.google.com"
 ]);
 var PROXY_MAX_BYTES = 16e6;
 var PROXY_TIMEOUT_MS = 2e4;
@@ -780,8 +1316,6 @@ import { access, readFile as readFile2 } from "fs/promises";
 import { constants } from "fs";
 import { tmpdir } from "os";
 import { dirname as dirname2, join as join2 } from "path";
-var AGENTS_LIST_ROUTE = "/__zframes/agents";
-var ASK_ROUTE = "/__zframes/ask";
 var MAX_BODY_BYTES2 = 64e3;
 var RUN_TIMEOUT_MS = 12e4;
 var RUNNERS = [
@@ -987,23 +1521,6 @@ function handleAsk(req, res, specFile) {
 
 // src/serve.ts
 var DEFAULT_PORT = 37263;
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".txt": "text/plain; charset=utf-8"
-};
 function parseArgs2(args) {
   let file = "dashboard.json";
   let port = DEFAULT_PORT;
@@ -1029,31 +1546,6 @@ function parseArgs2(args) {
   }
   return { file, port, contact };
 }
-function resolveWithin(rootDir, decodedPath) {
-  const rel = decodedPath === "/" ? "/index.html" : decodedPath;
-  const abs = resolve2(rootDir, `.${rel}`);
-  if (abs !== rootDir && !abs.startsWith(rootDir + sep)) return null;
-  return abs;
-}
-function sendFile(absPath, res) {
-  res.statusCode = 200;
-  res.setHeader(
-    "content-type",
-    MIME[extname(absPath).toLowerCase()] ?? "application/octet-stream"
-  );
-  createReadStream(absPath).pipe(res);
-}
-function tryStatic(rootDir, decodedPath, res) {
-  const abs = resolveWithin(rootDir, decodedPath);
-  if (!abs) return false;
-  try {
-    if (!statSync2(abs).isFile()) return false;
-  } catch {
-    return false;
-  }
-  sendFile(abs, res);
-  return true;
-}
 function serve(args) {
   const parsed = parseArgs2(args);
   if ("error" in parsed) {
@@ -1076,6 +1568,9 @@ function serve(args) {
     console.error("  run `pnpm build:cli` to build it.");
     return Promise.resolve(1);
   }
+  const serveBundle = sirv(bundleDir, { dev: true });
+  const serveSiblings = sirv(userDir, { dev: true });
+  const serveSpa = sirv(bundleDir, { dev: true, single: true });
   return new Promise((done) => {
     const server = createServer((req, res) => {
       const rawPath = (req.url ?? "/").split("?")[0];
@@ -1129,9 +1624,18 @@ function serve(args) {
         res.end();
         return;
       }
-      if (tryStatic(bundleDir, path, res)) return;
-      if (path !== "/" && tryStatic(userDir, path, res)) return;
-      sendFile(join3(bundleDir, "index.html"), res);
+      serveBundle(
+        req,
+        res,
+        () => serveSiblings(
+          req,
+          res,
+          () => serveSpa(req, res, () => {
+            res.statusCode = 404;
+            res.end();
+          })
+        )
+      );
     });
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
@@ -1144,7 +1648,7 @@ function serve(args) {
       done(1);
     });
     server.listen(parsed.port, "127.0.0.1", () => {
-      const url = `http://127.0.0.1:${parsed.port}`;
+      const url = `http://localhost:${parsed.port}`;
       console.log(`\u26A1 zframes is live at ${url}`);
       console.log(
         `   serving ${parsed.file} \u2014 live editing on; drag, resize, then Save writes back.`
@@ -1157,107 +1661,308 @@ function serve(args) {
 import { existsSync as existsSync3, readFileSync } from "fs";
 import { dirname as dirname3, resolve as resolve3 } from "path";
 
+// ../core/src/cache.ts
+var TtlCache = class {
+  entries = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  namespace;
+  ttlMs;
+  persist;
+  staleOnError;
+  revive;
+  constructor(options) {
+    this.namespace = options.namespace;
+    this.ttlMs = options.ttlMs;
+    this.persist = options.persist ?? false;
+    this.staleOnError = options.staleOnError ?? true;
+    this.revive = options.revive;
+  }
+  /**
+   * Resolve the value for `key`, calling `load` only on a miss or a stale entry.
+   * Serves a fresh cached value with no network call, coalesces concurrent loads
+   * onto one promise, and (by default) serves the last good value if `load` throws.
+   */
+  get(key, load) {
+    const entry = this.read(key);
+    if (entry && Date.now() - entry.at < this.ttlMs)
+      return Promise.resolve(entry.value);
+    const pending = this.inflight.get(key);
+    if (pending) return pending;
+    const promise = load().then((value) => {
+      this.write(key, value);
+      return value;
+    }).catch((error) => {
+      if (this.staleOnError && entry) return entry.value;
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /** Hydrate from memo, falling back to localStorage on a cold (persisted) read. */
+  read(key) {
+    const memo = this.entries.get(key);
+    if (memo) return memo;
+    if (!this.persist || typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(this.storageKey(key));
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (typeof parsed?.at !== "number") return null;
+      let value;
+      if (this.revive) {
+        const revived = this.revive(parsed.value);
+        if (revived === null) return null;
+        value = revived;
+      } else {
+        value = parsed.value;
+      }
+      const entry = { at: parsed.at, value };
+      this.entries.set(key, entry);
+      return entry;
+    } catch {
+      return null;
+    }
+  }
+  write(key, value) {
+    const entry = { at: Date.now(), value };
+    this.entries.set(key, entry);
+    if (!this.persist || typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(this.storageKey(key), JSON.stringify(entry));
+    } catch {
+    }
+  }
+  storageKey(key) {
+    return `${this.namespace}:${key}`;
+  }
+};
+
 // ../core/src/fetch.ts
 var DEFAULT_TIMEOUT_MS = 1e4;
 var USER_AGENT = "zframes (+https://github.com/zentryhq/zframes)";
-var PROXY_ROUTE = "/__zframes/proxy";
-async function fetchJson(url, schema, { timeoutMs = DEFAULT_TIMEOUT_MS, init: init2, proxied } = {}) {
+async function request(url, { timeoutMs = DEFAULT_TIMEOUT_MS, init: init2, proxied }) {
   const headers = new Headers(init2?.headers);
   if (typeof document === "undefined" && !headers.has("User-Agent")) {
     headers.set("User-Agent", USER_AGENT);
   }
-  const target = proxied && typeof document !== "undefined" ? `${PROXY_ROUTE}?url=${encodeURIComponent(url)}` : url;
+  const target = proxied && typeof document !== "undefined" ? `${DASHBOARD_PROXY_ROUTE}?url=${encodeURIComponent(url)}` : url;
   const res = await fetch(target, {
     ...init2,
     headers,
     signal: init2?.signal ?? AbortSignal.timeout(timeoutMs)
   });
   if (!res.ok) throw new Error(`${url} failed: ${res.status}`);
+  return res;
+}
+async function fetchJson(url, schema, opts = {}) {
+  const res = await request(url, opts);
   const body = await res.json();
   return schema ? schema.parse(body) : body;
 }
 
 // ../provider-alternativeme/src/index.ts
 var FNG_URL = "https://api.alternative.me/fng/";
+var sentimentCache = new TtlCache({
+  namespace: "zframes:alternativeme:fng",
+  ttlMs: 45 * 6e4,
+  persist: true,
+  revive: (value) => Array.isArray(value) ? value : null
+});
 var AlternativeMeProvider = class {
   name = "alternative.me";
   capabilities = ["sentiment"];
   async getFearGreed(limit = 30) {
-    const body = await fetchJson(`${FNG_URL}?limit=${limit}`);
-    if (!Array.isArray(body?.data))
-      throw new Error("alternative.me fng: unexpected response shape");
-    return body.data.map((entry) => ({
-      value: Number(entry.value),
-      classification: entry.value_classification ?? "",
-      time: Number(entry.timestamp) * 1e3
-    })).filter(
-      (point) => Number.isFinite(point.value) && Number.isFinite(point.time)
-    );
+    return sentimentCache.get(String(limit), async () => {
+      const body = await fetchJson(`${FNG_URL}?limit=${limit}`);
+      if (!Array.isArray(body?.data))
+        throw new Error("alternative.me fng: unexpected response shape");
+      return body.data.map((entry) => ({
+        value: Number(entry.value),
+        classification: entry.value_classification ?? "",
+        time: Number(entry.timestamp) * 1e3
+      })).filter(
+        (point) => Number.isFinite(point.value) && Number.isFinite(point.time)
+      );
+    });
   }
 };
 
 // ../provider-coingecko/src/index.ts
 var GLOBAL_URL = "https://api.coingecko.com/api/v3/global";
-var CACHE_KEY = "zframes:coingecko:global";
-var TTL_MS = 12 * 6e4;
-var memo = null;
-function readCache() {
-  if (memo) return memo;
-  try {
-    if (typeof localStorage !== "undefined") {
-      const raw = localStorage.getItem(CACHE_KEY);
-      if (raw) {
-        memo = JSON.parse(raw);
-        return memo;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-function writeCache(value) {
-  memo = { at: Date.now(), value };
-  try {
-    if (typeof localStorage !== "undefined")
-      localStorage.setItem(CACHE_KEY, JSON.stringify(memo));
-  } catch {
-  }
-}
+var MARKETS_URL = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=50&page=1&sparkline=false&price_change_percentage=24h";
+var globalCache = new TtlCache({
+  namespace: "zframes:coingecko:global",
+  ttlMs: 12 * 6e4,
+  persist: true
+});
+var marketsCache = new TtlCache({
+  namespace: "zframes:coingecko:markets",
+  ttlMs: 10 * 6e4,
+  persist: true
+});
 var CoinGeckoProvider = class {
   name = "coingecko";
-  capabilities = ["global-market"];
+  capabilities = [
+    "global-market",
+    "coin-markets"
+  ];
   async getGlobalMarket() {
-    const cached = readCache();
-    if (cached && Date.now() - cached.at < TTL_MS) return cached.value;
-    try {
+    return globalCache.get("global", async () => {
       const body = await fetchJson(GLOBAL_URL);
       if (!body?.data?.total_market_cap || !body.data.market_cap_percentage)
         throw new Error("coingecko global: unexpected response shape");
       const change = Number(body.data.market_cap_change_percentage_24h_usd);
-      const value = {
+      return {
         totalMarketCapUsd: body.data.total_market_cap.usd ?? 0,
         marketCapChangePct24h: Number.isFinite(change) ? change : 0,
         dominance: body.data.market_cap_percentage
       };
-      writeCache(value);
-      return value;
-    } catch (err) {
-      if (cached) return cached.value;
-      throw err;
-    }
+    });
+  }
+  async getCoinMarkets() {
+    return marketsCache.get("markets", async () => {
+      const body = await fetchJson(MARKETS_URL);
+      if (!Array.isArray(body))
+        throw new Error("coingecko markets: unexpected response shape");
+      return body.filter((c) => Number.isFinite(c.market_cap) && c.market_cap > 0).map((c) => ({
+        symbol: (c.symbol ?? "").toUpperCase(),
+        name: c.name,
+        marketCapUsd: c.market_cap,
+        changePct24h: Number.isFinite(c.price_change_percentage_24h) ? c.price_change_percentage_24h : void 0
+      }));
+    });
   }
 };
 
 // ../provider-defillama/src/index.ts
 var CHAINS_URL = "https://api.llama.fi/v2/chains";
+var DEXS_URL = "https://api.llama.fi/overview/dexs";
+var FEES_URL = "https://api.llama.fi/overview/fees";
+var PROTOCOLS_URL = "https://api.llama.fi/protocols";
+var SNAPSHOT_TTL_MS = 8 * 6e4;
+var HISTORY_TTL_MS = 30 * 6e4;
+var tvlCache = new TtlCache({
+  namespace: "zframes:defillama:tvl",
+  ttlMs: SNAPSHOT_TTL_MS
+});
+var dexVolumeCache = new TtlCache({
+  namespace: "zframes:defillama:dex-volume",
+  ttlMs: SNAPSHOT_TTL_MS
+});
+var protocolTvlCache = new TtlCache({
+  namespace: "zframes:defillama:protocol-tvl",
+  ttlMs: SNAPSHOT_TTL_MS
+});
+var protocolFeesCache = new TtlCache({
+  namespace: "zframes:defillama:protocol-fees",
+  ttlMs: SNAPSHOT_TTL_MS
+});
+var dexHistoryCache = new TtlCache({
+  namespace: "zframes:defillama:dex-history",
+  ttlMs: HISTORY_TTL_MS
+});
+var protocolHistoryCache = new TtlCache({
+  namespace: "zframes:defillama:protocol-history",
+  ttlMs: HISTORY_TTL_MS
+});
+var slugKey = (slugs) => [...slugs].sort().join(",");
+function toSeries(chart) {
+  if (!Array.isArray(chart)) return [];
+  return chart.map(([ts, value]) => ({ time: ts * 1e3, value: Number(value) })).filter((p) => Number.isFinite(p.time) && Number.isFinite(p.value));
+}
+var changeOf = (v) => Number.isFinite(v) ? v : void 0;
 var DefiLlamaProvider = class {
   name = "defillama";
-  capabilities = ["tvl"];
+  capabilities = [
+    "tvl",
+    "dex-volume",
+    "protocol-tvl",
+    "protocol-fees"
+  ];
   async getTvlByChain() {
-    const chains = await fetchJson(CHAINS_URL);
-    if (!Array.isArray(chains))
-      throw new Error("defillama chains: unexpected response shape");
-    return chains.filter((chain) => Number.isFinite(chain.tvl) && chain.tvl > 0).sort((a, b) => b.tvl - a.tvl).map((chain) => ({ name: chain.name, tvl: chain.tvl }));
+    return tvlCache.get("chains", async () => {
+      const chains = await fetchJson(CHAINS_URL);
+      if (!Array.isArray(chains))
+        throw new Error("defillama chains: unexpected response shape");
+      return chains.filter((chain) => Number.isFinite(chain.tvl) && chain.tvl > 0).sort((a, b) => b.tvl - a.tvl).map((chain) => ({ name: chain.name, tvl: chain.tvl }));
+    });
+  }
+  async getDexVolume() {
+    return dexVolumeCache.get("overview", async () => {
+      const body = await fetchJson(DEXS_URL);
+      const protocols = body?.protocols;
+      if (!Array.isArray(protocols))
+        throw new Error("defillama dexs: unexpected response shape");
+      return protocols.filter((p) => Number.isFinite(p.total24h) && (p.total24h ?? 0) > 0).map((p) => ({
+        name: p.name,
+        volume24h: p.total24h,
+        changePct: changeOf(p.change_1d)
+      })).sort((a, b) => b.volume24h - a.volume24h);
+    });
+  }
+  async getDexVolumeHistory(slugs) {
+    return dexHistoryCache.get(slugKey(slugs), async () => {
+      const pairs = await Promise.all(
+        slugs.map(
+          (slug) => fetchJson(
+            `https://api.llama.fi/summary/dexs/${encodeURIComponent(
+              slug
+            )}?excludeTotalDataChartBreakdown=true`
+          ).then((body) => [slug, toSeries(body.totalDataChart)]).catch(() => [slug, []])
+        )
+      );
+      return Object.fromEntries(pairs);
+    });
+  }
+  async getProtocolTvl() {
+    return protocolTvlCache.get("overview", async () => {
+      const protocols = await fetchJson(PROTOCOLS_URL);
+      if (!Array.isArray(protocols))
+        throw new Error("defillama protocols: unexpected response shape");
+      return protocols.filter((p) => Number.isFinite(p.tvl) && (p.tvl ?? 0) > 0).map((p) => ({
+        name: p.name,
+        tvl: p.tvl,
+        category: p.category,
+        changePct: changeOf(p.change_1d)
+      })).sort((a, b) => b.tvl - a.tvl);
+    });
+  }
+  async getProtocolTvlHistory(slugs) {
+    return protocolHistoryCache.get(slugKey(slugs), async () => {
+      const pairs = await Promise.all(
+        slugs.map(
+          (slug) => fetchJson(
+            `https://api.llama.fi/protocol/${encodeURIComponent(slug)}`
+          ).then(
+            (body) => [
+              slug,
+              (body.tvl ?? []).map((p) => ({
+                time: p.date * 1e3,
+                value: Number(p.totalLiquidityUSD)
+              })).filter(
+                (p) => Number.isFinite(p.time) && Number.isFinite(p.value)
+              )
+            ]
+          ).catch(() => [slug, []])
+        )
+      );
+      return Object.fromEntries(pairs);
+    });
+  }
+  async getProtocolFees() {
+    return protocolFeesCache.get("overview", async () => {
+      const body = await fetchJson(FEES_URL);
+      const protocols = body?.protocols;
+      if (!Array.isArray(protocols))
+        throw new Error("defillama fees: unexpected response shape");
+      return protocols.filter((p) => Number.isFinite(p.total24h) && (p.total24h ?? 0) > 0).map((p) => ({
+        name: p.name,
+        fees24h: p.total24h,
+        changePct: changeOf(p.change_1d)
+      })).sort((a, b) => b.fees24h - a.fees24h);
+    });
   }
 };
 
@@ -1280,7 +1985,8 @@ var HyperliquidProvider = class {
     "quote-stream",
     "day-stats",
     "funding-history",
-    "ohlcv"
+    "ohlcv",
+    "open-interest"
   ];
   ws = null;
   listeners = /* @__PURE__ */ new Set();
@@ -1339,6 +2045,39 @@ var HyperliquidProvider = class {
     );
     return out;
   }
+  async getOpenInterest(symbols) {
+    const wholeDexes = /* @__PURE__ */ new Set();
+    const concrete = /* @__PURE__ */ new Set();
+    if (!symbols) {
+      wholeDexes.add("");
+    } else {
+      for (const s of symbols) {
+        if (s.endsWith(":*")) wholeDexes.add(s.slice(0, -2));
+        else concrete.add(s);
+      }
+    }
+    const dexes = new Set(wholeDexes);
+    for (const s of concrete) dexes.add(dexOf(s));
+    const out = [];
+    await Promise.all(
+      [...dexes].map(async (dex) => {
+        const body = { type: "metaAndAssetCtxs" };
+        if (dex) body.dex = dex;
+        const [meta, ctxs] = await info(body);
+        const wholeDex = wholeDexes.has(dex);
+        meta.universe.forEach((asset, i) => {
+          if (!wholeDex && !concrete.has(asset.name)) return;
+          const ctx = ctxs[i];
+          if (!ctx) return;
+          const markPx = Number(ctx.markPx);
+          const oi = Number(ctx.openInterest);
+          if (!Number.isFinite(markPx) || !Number.isFinite(oi)) return;
+          out.push({ symbol: asset.name, openInterestUsd: oi * markPx });
+        });
+      })
+    );
+    return out.sort((a, b) => b.openInterestUsd - a.openInterestUsd);
+  }
   async getFundingHistory(symbols, startTimeMs) {
     const results = await Promise.all(
       symbols.map(async (coin) => {
@@ -1573,7 +2312,7 @@ usage:
                               frames) for the agent to fill in; --title <t>,
                               --author <a>, --force to overwrite
   zframes serve [file]        serve <dashboard.json> (default: ./dashboard.json)
-                              as a live, editable terminal at 127.0.0.1:37263
+                              as a live, editable terminal at localhost:37263
                               (--port <n> to change); Save writes back to the file
   zframes catalogue           print the frame catalogue as JSON Schema
                               (this is what a generating agent reads)
@@ -1584,56 +2323,6 @@ usage:
                               stdout (the deterministic half of /zframes-brief)
   zframes help                this text
 `;
-function lintSpec(spec) {
-  const issues = [];
-  const metaByName = new Map(frameMetas.map((meta) => [meta.name, meta]));
-  const seenIds = /* @__PURE__ */ new Set();
-  for (const instance of spec.frames) {
-    if (seenIds.has(instance.id))
-      issues.push({
-        frameId: instance.id,
-        message: `duplicate frame id "${instance.id}"`
-      });
-    seenIds.add(instance.id);
-    const meta = metaByName.get(instance.frame);
-    if (!meta) {
-      issues.push({
-        frameId: instance.id,
-        message: `unknown frame "${instance.frame}". available: ${[
-          ...metaByName.keys()
-        ].join(", ")}`
-      });
-      continue;
-    }
-    const parsed = meta.schema.safeParse(instance.config);
-    if (!parsed.success) {
-      for (const issue of parsed.error.issues) {
-        issues.push({
-          frameId: instance.id,
-          message: `config.${issue.path.join(".") || "(root)"}: ${issue.message}`
-        });
-      }
-    }
-    if (instance.position.x + instance.position.w > spec.grid.columns)
-      issues.push({
-        frameId: instance.id,
-        message: `overflows the grid: x(${instance.position.x}) + w(${instance.position.w}) > ${spec.grid.columns} columns`
-      });
-  }
-  for (let i = 0; i < spec.frames.length; i++) {
-    for (let j = i + 1; j < spec.frames.length; j++) {
-      const a = spec.frames[i].position;
-      const b = spec.frames[j].position;
-      const overlap = a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
-      if (overlap)
-        issues.push({
-          frameId: spec.frames[i].id,
-          message: `overlaps frame "${spec.frames[j].id}"`
-        });
-    }
-  }
-  return issues;
-}
 function lint(file) {
   let raw;
   try {
@@ -1698,7 +2387,16 @@ async function main() {
       return 1;
   }
 }
-main().then((code) => process.exit(code));
-export {
-  lintSpec
-};
+main().then(
+  (code) => {
+    if (process.stdout.write("")) {
+      process.exit(code);
+    } else {
+      process.stdout.once("drain", () => process.exit(code));
+    }
+  },
+  (error) => {
+    console.error(error);
+    process.exit(1);
+  }
+);