zframes 0.1.0

package/dist/index.js

@@ -0,0 +1,1707 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// ../core/src/catalogue.ts
+import { z } from "zod";
+function catalogueForAI(input) {
+  const metas = input instanceof Map ? [...input.values()] : [...input];
+  return metas.map((meta) => ({
+    name: meta.name,
+    description: meta.description,
+    iconUrl: meta.iconUrl,
+    capabilities: meta.capabilities,
+    // io: "input" — the agent writes the *input* shape, where .default()
+    // fields are optional. The output shape would wrongly mark them required.
+    configSchema: z.toJSONSchema(meta.schema, { io: "input" })
+  }));
+}
+
+// ../core/src/spec.ts
+import { z as z2 } from "zod";
+var GridPositionSchema = z2.object({
+  x: z2.number().int().min(0).describe("Column offset, 0-based"),
+  y: z2.number().int().min(0).describe("Row offset, 0-based"),
+  w: z2.number().int().min(1).describe("Width in grid columns"),
+  h: z2.number().int().min(1).describe("Height in grid rows")
+});
+var FrameInstanceSchema = z2.object({
+  id: z2.string().describe("Unique instance id within the dashboard"),
+  frame: z2.string().describe("Name of a registered frame"),
+  title: z2.string().optional().describe(
+    `Card title shown in the frame's chrome. Overrides the default (the frame type name) \u2014 set a meaningful per-instance label, e.g. the ticker on a price-chart ("TSLA"). Ignored by chrome-less frames like heading.`
+  ),
+  position: GridPositionSchema,
+  config: z2.record(z2.string(), z2.unknown()).default({}).describe(
+    "Frame config; validated against the frame's own schema at render time"
+  )
+});
+var BackgroundSchema = z2.object({
+  type: z2.enum(["none", "gradient", "unicorn"]).default("gradient").describe(
+    "Background style: 'gradient' (built-in dark glow), 'unicorn' (animated Unicorn Studio scene), or 'none'."
+  ),
+  projectId: z2.string().optional().describe(
+    "Unicorn Studio public project id \u2014 required when type is 'unicorn'."
+  ),
+  scale: z2.number().min(0.1).max(2).default(1).describe("Unicorn scene render scale."),
+  dpi: z2.number().min(0.5).max(3).default(1.5).describe("Unicorn scene device-pixel-ratio cap (perf vs sharpness)."),
+  opacity: z2.number().min(0).max(1).default(0.16).describe(
+    "Opacity of the unicorn scene (0\u20131). Keep moderate (~0.15) so the animation reads as a living backdrop in the gutters without competing with the (opaque) dashboard cards."
+  )
+}).describe("Visual background rendered behind the whole dashboard.");
+var ThemeSchema = z2.object({
+  accentHue: z2.number().int().min(0).max(360).default(242).describe(
+    "Brand accent hue in degrees on the HSL color wheel (0\u2013360). Rotates the dashboard's accent \u2014 card rims, title dots, chart highlights, loading states \u2014 across the spectrum. 242 is the default zframes indigo; rough anchors: 0 red, 35 orange, 50 amber, 150 green, 190 teal, 210 blue, 280 violet, 330 pink. Semantic up/down green/red, asset logos, and per-frame chart colors stay fixed."
+  ),
+  accentSat: z2.number().min(0).max(100).default(90).describe(
+    "Accent saturation as an HSL percentage (0\u2013100). 90 is the default vivid zframes accent; lower it for muted/pastel rims and dots, 0 for a near-grayscale monochrome accent. Pairs with accentHue \u2014 hue picks the color, saturation picks how vivid it is."
+  )
+}).describe("Dashboard-wide color identity (accent hue + saturation).");
+var AppearanceSchema = z2.object({
+  radius: z2.number().min(0).default(18).describe(
+    "Frame corner radius in pixels, applied to every card via --zf-frame-radius. 0 squares the corners; the editor's Appearance rail exposes this as a slider."
+  ),
+  borderStrength: z2.number().min(0).max(1).default(0.22).describe(
+    "Opacity of each card's accent rim (0\u20131) via --zf-border-alpha. 0 = borderless flat cards, 1 = a solid outlined rim; 0.22 is the default soft edge. Hover lifts it a notch automatically."
+  ),
+  surfaceOpacity: z2.number().min(0.3).max(1).default(1).describe(
+    "Opacity of the card surface (0.3\u20131) via --zf-surface-opacity. 1 = opaque cards (default); lower it toward 0.5 for frosted/glassy cards that let the dashboard background show through. Kept \u22650.3 so card content stays legible."
+  ),
+  density: z2.number().min(0.6).max(1.4).default(1).describe(
+    "Card padding scale (0.6\u20131.4) via --zf-density. 1 = the comfortable default; <1 tightens padding for information-dense dashboards, >1 gives roomier breathing space."
+  ),
+  elevation: z2.number().min(0).max(2).default(1).describe(
+    "Card shadow depth (0\u20132) via --zf-elevation. 0 = flat (no drop shadow), 1 = the default resting shadow, 2 = a heavier floating lift. Scales the card's drop shadow only."
+  )
+}).describe(
+  "Card surface treatment \u2014 corners, border, opacity, padding density, and shadow depth. Distinct from `grid` (geometry) and `theme` (accent color)."
+);
+var DashboardSpecSchema = z2.preprocess(
+  (raw) => {
+    if (!raw || typeof raw !== "object") return raw;
+    const r = raw;
+    const grid = r.grid;
+    if (grid && typeof grid === "object" && "radius" in grid) {
+      const { radius, ...restGrid } = grid;
+      return {
+        ...r,
+        grid: restGrid,
+        appearance: {
+          radius,
+          ...r.appearance ?? {}
+        }
+      };
+    }
+    return raw;
+  },
+  z2.object({
+    version: z2.coerce.string().default("1.0.0").describe(
+      'Spec version, a semver-style string like package.json\'s ("1.0.0"). A legacy numeric `1` from an older spec is coerced to "1".'
+    ),
+    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.`
+    ),
+    grid: z2.object({
+      columns: z2.number().int().min(1).default(12),
+      rowHeight: z2.number().min(8).default(96),
+      gap: z2.number().min(0).default(12).describe(
+        "Pixels of space between frames (the grid gutter). 0 makes the cards flush; the editor's Layout rail exposes this as a slider."
+      )
+    }).default({ columns: 12, rowHeight: 96, gap: 12 }),
+    background: BackgroundSchema.default({
+      type: "gradient",
+      scale: 1,
+      dpi: 1.5,
+      opacity: 0.16
+    }),
+    theme: ThemeSchema.default({ accentHue: 242, accentSat: 90 }),
+    appearance: AppearanceSchema.default({
+      radius: 18,
+      borderStrength: 0.22,
+      surfaceOpacity: 1,
+      density: 1,
+      elevation: 1
+    }),
+    frames: z2.array(FrameInstanceSchema)
+  })
+);
+
+// ../core/src/frame.ts
+function defineFrameMeta(meta) {
+  return meta;
+}
+
+// ../frames/src/schemas.ts
+import { z as z3 } from "zod";
+var widgetIcon = (name) => `/widget-icons/${name}.png`;
+var SOURCES = {
+  hyperliquid: { name: "Hyperliquid", url: "https://hyperliquid.xyz" },
+  defillama: { name: "DeFiLlama", url: "https://defillama.com" },
+  coingecko: { name: "CoinGecko", url: "https://www.coingecko.com" },
+  alternativeMe: {
+    name: "alternative.me",
+    url: "https://alternative.me/crypto/fear-and-greed-index/"
+  },
+  bls: { name: "BLS", url: "https://www.bls.gov" },
+  nyFed: {
+    name: "NY Fed",
+    url: "https://www.newyorkfed.org/markets/reference-rates"
+  },
+  treasury: { name: "U.S. Treasury", url: "https://fiscaldata.treasury.gov" },
+  secEdgar: { name: "SEC EDGAR", url: "https://www.sec.gov/edgar" },
+  finra: {
+    name: "FINRA",
+    url: "https://www.finra.org/finra-data/browse-catalog/short-sale-volume-data"
+  }
+};
+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.",
+  capabilities: [],
+  schema: z3.object({
+    timezone: z3.string().default("").describe(
+      `IANA timezone, e.g. "America/New_York", "Europe/London", "Asia/Tokyo", "UTC". Empty = the viewer's local timezone.`
+    ),
+    label: z3.string().default("").describe(
+      'Caption under the time, e.g. "New York" or "Local". Empty hides it.'
+    ),
+    hour12: z3.boolean().default(false).describe("12-hour clock with AM/PM (true) or 24-hour (false)."),
+    showSeconds: z3.boolean().default(true).describe("Show seconds (HH:MM:SS) instead of just HH:MM."),
+    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.")
+  })
+});
+var marketHoursMeta = defineFrameMeta({
+  name: "market-hours",
+  iconUrl: widgetIcon("market-hours"),
+  layout: { w: 4, h: 4, minW: 3, minH: 3 },
+  description: "Which world stock exchanges are open right now \u2014 each row shows an open / closed / holiday status dot and a live countdown to the next open or close. Computed entirely client-side from each exchange's timezone and regular trading hours (no API); a bundled 2026 holiday list keeps the major Western exchanges accurate on market holidays. Intraday lunch breaks and half-day early closes are not modelled. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({
+    exchanges: z3.array(z3.string()).default([]).describe(
+      'Exchange codes to show, e.g. ["NYSE","LSE","TSE","HKEX","SET"]. Empty = a global default set. Known codes: NYSE, NASDAQ, TSX, B3, LSE, XETRA, EURONEXT, SIX, TSE, HKEX, SSE, NSE, KRX, SGX, SET, ASX, JSE, TADAWUL.'
+    ),
+    sort: z3.enum(["region", "status", "name"]).default("region").describe(
+      "Order rows by world region (Americas \u2192 Europe \u2192 Asia-Pacific \u2192 Middle East/Africa), by status (open first), or alphabetically by name."
+    )
+  })
+});
+var fearGreedMeta = defineFrameMeta({
+  name: "fear-greed",
+  iconUrl: widgetIcon("fear-greed"),
+  layout: { w: 3, h: 3, minW: 2, minH: 2 },
+  description: "Crypto Fear & Greed index (0 = extreme fear, 100 = extreme greed) with a recent-history sparkline. A one-number market mood gauge from alternative.me.",
+  capabilities: ["sentiment"],
+  source: SOURCES.alternativeMe,
+  schema: z3.object({
+    sparklineDays: z3.number().int().min(7).max(90).default(30).describe("How many days of index history to show in the sparkline.")
+  })
+});
+var fundingRateChartMeta = defineFrameMeta({
+  name: "funding-rate-chart",
+  iconUrl: widgetIcon("funding-rate-chart"),
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Multi-series line chart comparing hourly perp funding rates across symbols over a configurable lookback window. Positive funding = longs pay shorts. Useful for spotting crowded trades.",
+  capabilities: ["funding-history"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    symbols: z3.array(z3.string()).min(1).max(6).describe(
+      'Hyperliquid symbols to compare funding for, e.g. ["xyz:TSLA", "xyz:NVDA"]. Up to 6.'
+    ),
+    lookback: z3.enum(["24h", "7D", "1M"]).default("7D").describe("History window for the funding chart.")
+  })
+});
+var noteMeta = defineFrameMeta({
+  name: "note",
+  iconUrl: widgetIcon("note"),
+  layout: { w: 4, h: 3, minW: 2, minH: 2 },
+  description: "Free-form text note pinned to the dashboard \u2014 trading plans, reminders, watch levels. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({
+    text: z3.string().min(1).describe("The note's text content. Plain text; newlines are preserved."),
+    align: z3.enum(["left", "center"]).default("left").describe("Text alignment inside the card.")
+  })
+});
+var priceChartMeta = defineFrameMeta({
+  name: "price-chart",
+  iconUrl: widgetIcon("price-chart"),
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Live animated price chart (candlestick or line) for one symbol \u2014 canvas-rendered at 60fps via liveline, streaming live off the Hyperliquid WebSocket. Works for HIP-3 stock perps (xyz:TSLA) and crypto (BTC). The centerpiece frame.",
+  capabilities: ["ohlcv", "quote-stream"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    symbol: z3.string().min(1).describe(
+      'Hyperliquid symbol to chart. Stocks/HIP-3: "xyz:TSLA", "xyz:NVDA", "xyz:AAPL". Crypto: "BTC", "ETH".'
+    ),
+    interval: z3.enum(["1m", "5m", "15m", "1h", "4h", "1d"]).default("1h").describe("Candle interval."),
+    mode: z3.enum(["candle", "line"]).default("candle").describe("Candlestick or smooth line rendering."),
+    color: z3.string().default("#8b8df9").describe("Accent color (hex). The whole palette derives from it.")
+  })
+});
+var priceLivelineMeta = defineFrameMeta({
+  name: "price-liveline",
+  iconUrl: widgetIcon("price-liveline"),
+  layout: { w: 6, h: 3, minW: 4, minH: 2 },
+  description: "Multi-asset live price liveline \u2014 several Hyperliquid symbols streaming in one canvas chart. Defaults to normalized % movement so stocks and crypto can share one axis, while the legend still shows each asset's live raw price. Use when the dashboard needs one compact live race view instead of several single-symbol charts.",
+  capabilities: ["quote-stream", "day-stats"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    symbols: z3.array(z3.string()).min(2).max(8).describe(
+      'Hyperliquid symbols to stream together, e.g. ["xyz:TSLA", "xyz:NVDA", "xyz:AAPL"] or ["BTC", "ETH", "SOL"]. 2 to 8.'
+    ),
+    windowSec: z3.number().int().min(10).max(300).default(30).describe(
+      "Rolling live window in seconds. 30 mirrors the zhive liveline view; use 60\u2013300 for slower dashboards."
+    ),
+    normalize: z3.boolean().default(true).describe(
+      "Show each asset as % movement from its first live tick (recommended when prices differ). Off = raw price overlay."
+    )
+  })
+});
+var priceTickerMeta = defineFrameMeta({
+  name: "price-ticker",
+  iconUrl: widgetIcon("price-ticker"),
+  layout: { w: 3, h: 3, minW: 2, minH: 2 },
+  description: "Live watchlist streaming mid prices over the Hyperliquid WebSocket with 24h change per symbol. The bread-and-butter frame for any dashboard.",
+  capabilities: ["quote-stream", "day-stats"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    symbols: z3.array(z3.string()).min(1).describe(
+      'Hyperliquid symbols to track, e.g. ["xyz:TSLA", "xyz:NVDA", "xyz:AAPL"]. Crypto works too: "BTC", "ETH".'
+    )
+  })
+});
+var topMoversMeta = defineFrameMeta({
+  name: "top-movers",
+  iconUrl: widgetIcon("top-movers"),
+  layout: { w: 5, h: 3, minW: 3, minH: 3 },
+  description: "Today's biggest stock and commodity HIP-3 gainers and losers (no bare crypto), side by side with current price and 24h change.",
+  capabilities: ["day-stats"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    count: z3.number().int().min(3).max(10).default(5).describe("How many gainers and losers to list (each).")
+  })
+});
+var tvlTreemapMeta = defineFrameMeta({
+  name: "tvl-treemap",
+  iconUrl: widgetIcon("tvl-treemap"),
+  layout: { w: 6, h: 4, minW: 3, minH: 3 },
+  description: "Treemap of total value locked (TVL) across the largest blockchain ecosystems, sized by TVL. Data from DeFiLlama. Good single-glance answer to 'where does on-chain capital live right now'.",
+  capabilities: ["tvl"],
+  source: SOURCES.defillama,
+  schema: z3.object({
+    topN: z3.number().int().min(3).max(30).default(12).describe("How many of the largest chains to show in the treemap.")
+  })
+});
+var bitcoinDominanceMeta = defineFrameMeta({
+  name: "bitcoin-dominance",
+  iconUrl: widgetIcon("bitcoin-dominance"),
+  layout: { w: 4, h: 2, minW: 3, minH: 2 },
+  description: "BTC / ETH / Others market-cap dominance as a segmented bar, with optional total marketcap line. Shifts in BTC dominance hint at where the market rotates next.",
+  capabilities: ["global-market"],
+  source: SOURCES.coingecko,
+  schema: z3.object({
+    showTotalMarketCap: z3.boolean().default(true).describe(
+      "Show total crypto marketcap and its 24h change below the bar."
+    )
+  })
+});
+var ratesBoardMeta = defineFrameMeta({
+  name: "rates-board",
+  iconUrl: widgetIcon("rates-board"),
+  layout: { w: 4, h: 4, minW: 3, minH: 3 },
+  description: "Official US rates board from free public APIs: New York Fed reference rates (SOFR, effective fed funds, repo rates) plus Treasury average interest rates by security class. Daily/reference data, not a real-time stock quote feed.",
+  capabilities: ["reference-rates", "treasury-rates"],
+  source: [SOURCES.nyFed, SOURCES.treasury],
+  schema: z3.object({
+    maxReferenceRates: z3.number().int().min(2).max(8).default(5).describe("How many New York Fed reference rates to show."),
+    showTreasuryAverageRates: z3.boolean().default(true).describe(
+      "Also show Treasury average interest rates by security class from Fiscal Data."
+    ),
+    maxTreasuryRates: z3.number().int().min(1).max(8).default(4).describe("How many Treasury average-rate rows to show.")
+  })
+});
+var inflationPulseMeta = defineFrameMeta({
+  name: "inflation-pulse",
+  iconUrl: widgetIcon("inflation-pulse"),
+  layout: { w: 4, h: 3, minW: 3, minH: 2 },
+  description: "BLS CPI pulse from the public no-key API: latest CPI-U all-items index with month-over-month and year-over-year changes plus a small trend sparkline. Monthly macro context for stock dashboards; not a live price feed.",
+  capabilities: ["macro-series"],
+  source: SOURCES.bls,
+  schema: z3.object({
+    months: z3.number().int().min(13).max(36).default(18).describe("How many monthly CPI observations to show in the trend.")
+  })
+});
+var filingsFeedMeta = defineFrameMeta({
+  name: "filings-feed",
+  iconUrl: widgetIcon("filings-feed"),
+  layout: { w: 5, h: 4, minW: 3, minH: 3 },
+  description: "Recent SEC EDGAR filings for one US-listed company \u2014 each row shows the form type (10-K, 10-Q, 8-K, Form 4\u2026), a plain-English label, the filing date, and a click-through to the document on sec.gov, under a header with the company name, exchange, and filer category. Official data from SEC's free, CORS-safe submissions endpoint; event-driven (updates when the company files), not a price feed. Resolve by ticker (a bundled snapshot of the ~500 largest US issuers) or by raw SEC CIK for anything else.",
+  capabilities: ["filings"],
+  source: SOURCES.secEdgar,
+  schema: z3.object({
+    symbol: z3.string().min(1).describe(
+      'Company to show filings for \u2014 a ticker ("AAPL", "NVDA"), a HIP-3 symbol ("xyz:TSLA"), or a raw SEC CIK ("320193"). Tickers outside the bundled top-500 map need a CIK.'
+    ),
+    forms: z3.enum(["important", "all", "insider"]).default("important").describe(
+      'Which filings to surface: "important" = periodic & material reports (10-K, 10-Q, 8-K, S-1, proxies, 13D/G\u2026); "insider" = ownership forms (3/4/5/144); "all" = unfiltered. Always newest first.'
+    ),
+    count: z3.number().int().min(3).max(25).default(8).describe("How many filings to list (newest first).")
+  })
+});
+var yieldCurveMeta = defineFrameMeta({
+  name: "yield-curve",
+  iconUrl: widgetIcon("yield-curve"),
+  layout: { w: 4, h: 3, minW: 3, minH: 3 },
+  description: "The U.S. Treasury daily par yield curve \u2014 a line from 1-month to 30-year yields, the headline 2s10s spread (10Y minus 2Y; negative = inverted, the classic recession signal), and a configurable row of key maturities. Keyless official data from the U.S. Treasury, updated each business day; not a live intraday feed.",
+  capabilities: ["yield-curve"],
+  source: SOURCES.treasury,
+  schema: z3.object({
+    maturities: z3.array(
+      z3.enum([
+        "1M",
+        "2M",
+        "3M",
+        "4M",
+        "6M",
+        "1Y",
+        "2Y",
+        "3Y",
+        "5Y",
+        "7Y",
+        "10Y",
+        "20Y",
+        "30Y"
+      ])
+    ).min(2).max(8).default(["3M", "2Y", "5Y", "10Y", "30Y"]).describe(
+      "Maturities to show as labelled cells under the curve (the full curve line always shows every maturity)."
+    )
+  })
+});
+var fundamentalsMeta = defineFrameMeta({
+  name: "fundamentals",
+  iconUrl: widgetIcon("fundamentals"),
+  layout: { w: 4, h: 3, minW: 3, minH: 3 },
+  description: "Headline financials for one US-listed company from SEC EDGAR XBRL company facts \u2014 revenue, net income, total assets, shareholders' equity, diluted EPS, and shares outstanding, each labelled with its fiscal period. Income-statement figures are the latest full fiscal year; balance-sheet figures are the latest reported quarter. Keyless official data that updates only when the company files (annual/quarterly), not a live feed. Requires the zframes runtime's data proxy (it ships with `zframes serve` / `vite dev`); resolve by ticker (bundled top-500 map) or raw SEC CIK.",
+  capabilities: ["fundamentals"],
+  source: SOURCES.secEdgar,
+  schema: z3.object({
+    symbol: z3.string().min(1).describe(
+      'Company to show financials for \u2014 a ticker ("AAPL", "NVDA"), a HIP-3 symbol ("xyz:NVDA"), or a raw SEC CIK ("320193"). Tickers outside the bundled top-500 map need a CIK.'
+    )
+  })
+});
+var shortVolumeMeta = defineFrameMeta({
+  name: "short-volume",
+  iconUrl: widgetIcon("short-volume"),
+  layout: { w: 5, h: 4, minW: 3, minH: 3 },
+  description: "Daily reported short-sale volume for a watchlist of US-listed stocks, from FINRA's free consolidated file \u2014 each row shows the % of the day's reported volume that was sold short, with a bar and the raw short/total share counts. IMPORTANT: this is reported short volume (sell-side short flow, which includes market-maker hedging), NOT short interest (outstanding short positions), and is not a directional signal on its own. Daily data published the next business day; not a live feed. US equities only.",
+  capabilities: ["short-volume"],
+  source: SOURCES.finra,
+  schema: z3.object({
+    symbols: z3.array(z3.string()).min(1).max(12).describe(
+      'US-listed stock tickers to show, e.g. ["TSLA","NVDA","AAPL"]. HIP-3 symbols ("xyz:TSLA") work too \u2014 the dex prefix is stripped. Crypto has no SEC/FINRA short-volume and is ignored.'
+    ),
+    sort: z3.enum(["shortPct", "volume", "symbol"]).default("shortPct").describe(
+      "Order rows by short % of volume (highest first), by total volume (highest first), or alphabetically by symbol."
+    )
+  })
+});
+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.",
+  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"].'
+    )
+  })
+});
+var dinoGameMeta = defineFrameMeta({
+  name: "dino-game",
+  iconUrl: widgetIcon("dino-game"),
+  layout: { w: 4, h: 3, minW: 3, minH: 3 },
+  description: "Chrome-dino style runner game on canvas \u2014 jump cacti with SPACE or tap. High score persists locally. For when the market is boring. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({})
+});
+var imageMeta = defineFrameMeta({
+  name: "image",
+  iconUrl: widgetIcon("image"),
+  layout: { w: 3, h: 3, minW: 1, minH: 1 },
+  description: "Displays an image from a URL \u2014 logos, memes, chart screenshots, banners. Needs no data provider.",
+  capabilities: [],
+  schema: z3.object({
+    url: z3.string().min(1).describe("Image URL (https)."),
+    alt: z3.string().default("").describe("Alt text for accessibility."),
+    fit: z3.enum(["cover", "contain"]).default("cover").describe(
+      "How the image fills the frame: cover crops, contain letterboxes."
+    )
+  })
+});
+var headingMeta = defineFrameMeta({
+  name: "heading",
+  iconUrl: widgetIcon("heading"),
+  layout: { w: 12, h: 1, minW: 2, minH: 1, maxH: 1 },
+  description: "Section divider that titles a region of the dashboard ('Markets', 'On-chain', 'Desk'). Renders as a label with a hairline rule \u2014 no card. Use to group frames into zones: place full-width (w: 12) and 1 row tall (h: 1) above each group. Needs no data provider.",
+  capabilities: [],
+  chrome: "bare",
+  schema: z3.object({
+    title: z3.string().min(1).describe("The heading text."),
+    subtitle: z3.string().optional().describe("Smaller supporting line under the title.")
+  })
+});
+var dailyAnalysisMeta = defineFrameMeta({
+  name: "daily-analysis",
+  iconUrl: widgetIcon("daily-analysis"),
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Daily market brief written by the /zframes-brief loop \u2014 a dated analysis of the symbols on your dashboard, the calls it is making today, and how yesterday's calls scored (with a running hit-rate). Reads a local log file the loop appends to; needs no market data provider. Add one per dashboard.",
+  capabilities: [],
+  schema: z3.object({
+    src: z3.string().default("/daily-analysis.json").describe(
+      "URL of the analysis log the loop writes, served from the app's public/ dir. Leave as the default unless you renamed the file."
+    ),
+    entries: z3.number().int().min(1).max(5).default(1).describe(
+      "How many of the most recent daily entries to show (newest first)."
+    ),
+    refreshSec: z3.number().int().min(30).default(300).describe(
+      "How often (seconds) to re-fetch the log so a fresh brief appears without a manual reload."
+    )
+  })
+});
+var priceCompareMeta = defineFrameMeta({
+  name: "price-compare",
+  iconUrl: widgetIcon("price-compare"),
+  layout: { w: 6, h: 3, minW: 3, minH: 2 },
+  description: "Multi-series line chart overlaying the price history of several symbols over a lookback window \u2014 see how TSLA, NVDA and BTC moved against each other. Normalized by default to % change from the window start so symbols at very different price levels (BTC vs a $20 stock) stay comparable on one axis. Candles from Hyperliquid.",
+  capabilities: ["ohlcv"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    symbols: z3.array(z3.string()).min(2).max(6).describe(
+      'Hyperliquid symbols to overlay, e.g. ["xyz:TSLA", "xyz:NVDA", "BTC"]. 2 to 6.'
+    ),
+    lookback: z3.enum(["24h", "7D", "1M"]).default("7D").describe("History window for the comparison."),
+    normalize: z3.boolean().default(true).describe(
+      "Rebase each series to % change from the window start (recommended \u2014 lets symbols at different price levels share one axis). Off = raw price, only sensible when comparing similarly-priced symbols."
+    )
+  })
+});
+var allocationMeta = defineFrameMeta({
+  name: "allocation",
+  iconUrl: widgetIcon("allocation"),
+  layout: { w: 4, h: 4, minW: 3, minH: 3 },
+  description: "Donut of a portfolio's live allocation \u2014 list holdings (symbol + amount) and each slice is sized by current USD value off the Hyperliquid mid stream, with total portfolio value in the center. A live 'where is my money right now' view.",
+  capabilities: ["quote-stream"],
+  source: SOURCES.hyperliquid,
+  schema: z3.object({
+    holdings: z3.array(
+      z3.object({
+        symbol: z3.string().min(1).describe('Hyperliquid symbol, e.g. "BTC", "ETH", "xyz:TSLA".'),
+        amount: z3.number().positive().describe(
+          "Units held (e.g. 0.5 BTC, 10 shares). Weights the slice by USD value = amount \xD7 live price."
+        )
+      })
+    ).min(2).max(8).describe("The holdings to chart. 2 to 8 positions.")
+  })
+});
+var frameMetas = [
+  allocationMeta,
+  bitcoinDominanceMeta,
+  clockMeta,
+  dailyAnalysisMeta,
+  dinoGameMeta,
+  fearGreedMeta,
+  filingsFeedMeta,
+  fundamentalsMeta,
+  fundingHeatmapMeta,
+  fundingRateChartMeta,
+  headingMeta,
+  imageMeta,
+  inflationPulseMeta,
+  marketHoursMeta,
+  noteMeta,
+  priceChartMeta,
+  priceCompareMeta,
+  priceLivelineMeta,
+  priceTickerMeta,
+  ratesBoardMeta,
+  shortVolumeMeta,
+  topMoversMeta,
+  tvlTreemapMeta,
+  yieldCurveMeta
+];
+
+// src/init.ts
+import { existsSync, mkdirSync, statSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+function parseArgs(args) {
+  let target = "dashboard.json";
+  let title = "my dashboard";
+  let author = "";
+  let force = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--title" || a === "-t") {
+      title = args[++i] ?? "";
+    } else if (a.startsWith("--title=")) {
+      title = a.slice("--title=".length);
+    } else if (a === "--author" || a === "-a") {
+      author = args[++i] ?? "";
+    } else if (a.startsWith("--author=")) {
+      author = a.slice("--author=".length);
+    } else if (a === "--force" || a === "-f") {
+      force = true;
+    } else if (!a.startsWith("-")) {
+      target = a;
+    } else {
+      return { error: `unknown option "${a}"` };
+    }
+  }
+  if (!title.trim()) return { error: "--title cannot be empty" };
+  return { target, title, author, force };
+}
+function resolveDest(target) {
+  const abs = resolve(process.cwd(), target);
+  if (abs.toLowerCase().endsWith(".json")) return abs;
+  return resolve(abs, "dashboard.json");
+}
+function skeleton(title, author) {
+  return {
+    version: "1.0.0",
+    title,
+    author,
+    grid: { columns: 12, rowHeight: 96, gap: 12 },
+    background: {
+      type: "unicorn",
+      projectId: "K42KSY4FXeXhjVOj9RgT",
+      opacity: 0.05
+    },
+    theme: { accentHue: 242, accentSat: 90 },
+    appearance: {
+      radius: 18,
+      borderStrength: 0.22,
+      surfaceOpacity: 1,
+      density: 1,
+      elevation: 1
+    },
+    frames: []
+  };
+}
+function init(args) {
+  const parsed = parseArgs(args);
+  if ("error" in parsed) {
+    console.error(`\u2717 ${parsed.error}`);
+    console.error(
+      "usage: zframes init [dir|file.json] [--title <t>] [--author <a>] [--force]"
+    );
+    return 1;
+  }
+  const dest = resolveDest(parsed.target);
+  if (existsSync(dest)) {
+    if (!parsed.force) {
+      console.error(`\u2717 ${dest} already exists`);
+      console.error(
+        "  edit it directly, or pass --force to overwrite with a bare skeleton."
+      );
+      return 1;
+    }
+    if (!statSync(dest).isFile()) {
+      console.error(`\u2717 ${dest} exists but is not a file`);
+      return 1;
+    }
+  }
+  const spec = skeleton(parsed.title, parsed.author);
+  const check = DashboardSpecSchema.safeParse(spec);
+  if (!check.success) {
+    console.error("\u2717 internal error: bare skeleton failed validation");
+    for (const issue of check.error.issues)
+      console.error(`  ${issue.path.join(".") || "(root)"}: ${issue.message}`);
+    return 1;
+  }
+  try {
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, `${JSON.stringify(spec, null, 2)}
+`);
+  } catch (error) {
+    console.error(`\u2717 could not write ${dest}: ${error.message}`);
+    return 1;
+  }
+  const hint = parsed.target.toLowerCase().endsWith(".json") ? parsed.target : join(parsed.target, "dashboard.json");
+  console.log(`\u2713 wrote a bare dashboard to ${dest}`);
+  console.log("  next: read the catalogue, add frames, then lint + serve:");
+  console.log("    npx zframes@latest catalogue");
+  console.log(`    npx zframes@latest lint ${hint}`);
+  console.log(`    npx zframes@latest serve ${hint}`);
+  return 0;
+}
+
+// src/serve.ts
+import { createReadStream, existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { createServer } from "http";
+import { extname, join as join3, resolve as resolve2, sep } from "path";
+import { fileURLToPath } from "url";
+
+// ../core/src/serve.ts
+import { readFile, writeFile } from "fs/promises";
+var DASHBOARD_READ_ROUTE = "/__zframes/dashboard.json";
+var DASHBOARD_WRITE_ROUTE = "/__zframes/dashboard";
+var DASHBOARD_PROXY_ROUTE = "/__zframes/proxy";
+var MAX_BODY_BYTES = 2e6;
+var PROXY_ALLOW_HOSTS = /* @__PURE__ */ new Set([
+  "data.sec.gov",
+  "www.sec.gov",
+  "efts.sec.gov",
+  "www.federalreserve.gov",
+  "www.financialresearch.gov",
+  "www.nasdaqtrader.com",
+  "www.nyse.com",
+  "markets.newyorkfed.org",
+  "api.fiscaldata.treasury.gov",
+  "api.bls.gov",
+  "cdn.finra.org"
+]);
+var PROXY_MAX_BYTES = 16e6;
+var PROXY_TIMEOUT_MS = 2e4;
+var PROXY_DEFAULT_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36";
+async function handleSpecRead(absFile, res) {
+  res.setHeader("cache-control", "no-store");
+  res.setHeader("content-type", "application/json");
+  try {
+    res.statusCode = 200;
+    res.end(await readFile(absFile, "utf8"));
+  } catch (error) {
+    res.statusCode = error.code === "ENOENT" ? 404 : 500;
+    res.end(JSON.stringify({ ok: false, error: String(error) }));
+  }
+}
+function handleSpecWrite(req, res, absFile) {
+  if (req.method !== "PUT" && req.method !== "POST") {
+    res.statusCode = 405;
+    res.end();
+    return;
+  }
+  if (!String(req.headers["content-type"] ?? "").includes("application/json")) {
+    res.statusCode = 415;
+    res.end();
+    return;
+  }
+  let body = "";
+  let aborted = false;
+  req.on("data", (chunk) => {
+    if (aborted) return;
+    body += chunk;
+    if (body.length > MAX_BODY_BYTES) {
+      aborted = true;
+      res.statusCode = 413;
+      res.end();
+      req.destroy();
+    }
+  });
+  req.on("end", async () => {
+    if (aborted) return;
+    try {
+      const json = JSON.parse(body);
+      await writeFile(absFile, `${JSON.stringify(json, null, 2)}
+`, "utf8");
+      res.statusCode = 200;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ ok: true, file: absFile }));
+    } catch (error) {
+      res.statusCode = 400;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ ok: false, error: String(error) }));
+    }
+  });
+}
+function proxyError(res, status, error) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify({ ok: false, error }));
+}
+async function handleProxy(req, res, opts = {}) {
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    proxyError(res, 405, "proxy is GET-only");
+    return;
+  }
+  const query = (req.url ?? "").split("?")[1] ?? "";
+  const raw = new URLSearchParams(query).get("url");
+  let target;
+  try {
+    target = new URL(raw ?? "");
+  } catch {
+    proxyError(res, 400, "missing or invalid ?url=");
+    return;
+  }
+  if (target.protocol !== "https:") {
+    proxyError(res, 400, "only https targets are allowed");
+    return;
+  }
+  if (!PROXY_ALLOW_HOSTS.has(target.hostname)) {
+    proxyError(res, 403, `host not allowed: ${target.hostname}`);
+    return;
+  }
+  try {
+    const upstream = await fetch(target.toString(), {
+      headers: {
+        "User-Agent": opts.userAgent ?? PROXY_DEFAULT_UA,
+        Accept: "application/json,text/plain,*/*"
+      },
+      redirect: "follow",
+      signal: AbortSignal.timeout(PROXY_TIMEOUT_MS)
+    });
+    const text = await upstream.text();
+    if (text.length > PROXY_MAX_BYTES) {
+      proxyError(res, 502, "upstream response too large");
+      return;
+    }
+    res.statusCode = upstream.status;
+    res.setHeader(
+      "content-type",
+      upstream.headers.get("content-type") ?? "application/octet-stream"
+    );
+    res.setHeader("cache-control", "no-store");
+    res.end(text);
+  } catch (error) {
+    proxyError(res, 502, `upstream fetch failed: ${String(error)}`);
+  }
+}
+
+// ../core/src/agent.ts
+import { spawn } from "child_process";
+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 = [
+  {
+    id: "claude",
+    label: "Claude",
+    bin: "claude",
+    // -p/--print is non-interactive; text format prints just the answer.
+    buildArgs: (prompt) => ["-p", prompt, "--output-format", "text"],
+    readResult: async (stdout) => stdout.trim()
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    bin: "codex",
+    // `exec` is non-interactive; read-only sandbox so a Q&A can't mutate
+    // anything, and -o writes ONLY the final message to a file (stdout carries
+    // session noise). --skip-git-repo-check so it runs outside a repo too.
+    buildArgs: (prompt, outFile) => [
+      "exec",
+      "--skip-git-repo-check",
+      "-s",
+      "read-only",
+      "--color",
+      "never",
+      "-o",
+      outFile,
+      prompt
+    ],
+    readResult: async (stdout, outFile) => {
+      try {
+        return (await readFile2(outFile, "utf8")).trim();
+      } catch {
+        return stdout.trim();
+      }
+    }
+  },
+  {
+    id: "kimi",
+    label: "Kimi",
+    bin: "kimi",
+    // -p/--prompt runs one prompt non-interactively and prints the response.
+    buildArgs: (prompt) => ["-p", prompt, "--output-format", "text"],
+    readResult: async (stdout) => stdout.trim()
+  }
+];
+async function onPath(bin) {
+  for (const dir of (process.env.PATH ?? "").split(":")) {
+    if (!dir) continue;
+    try {
+      await access(join2(dir, bin), constants.X_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var detected = null;
+function detectAgents() {
+  if (!detected) {
+    detected = Promise.all(
+      RUNNERS.map(async (r) => await onPath(r.bin) ? r : null)
+    ).then((rs) => rs.filter((r) => r !== null));
+  }
+  return detected;
+}
+async function buildPrompt(specFile, question) {
+  let title = "a live market dashboard";
+  const symbols = /* @__PURE__ */ new Set();
+  try {
+    const spec = JSON.parse(await readFile2(specFile, "utf8"));
+    if (typeof spec.title === "string" && spec.title) title = spec.title;
+    for (const frame of spec.frames ?? []) {
+      const cfg = frame.config ?? {};
+      if (typeof cfg.symbol === "string") symbols.add(cfg.symbol);
+      if (Array.isArray(cfg.symbols)) {
+        for (const s of cfg.symbols) if (typeof s === "string") symbols.add(s);
+      }
+    }
+  } catch {
+  }
+  const universe = symbols.size ? [...symbols].join(", ") : "no specific symbols";
+  return `You are zAI, a market assistant embedded in a live dashboard titled "${title}". The symbols on screen right now are: ${universe}. Answer the user's question in 2\u20134 sentences of plain text \u2014 no markdown headings, no preamble, no tool use, just the answer.
+
+Question: ${question}`;
+}
+var askCounter = 0;
+function runAgent(runner, prompt, cwd) {
+  const outFile = join2(
+    tmpdir(),
+    `zframes-ask-${process.pid}-${++askCounter}.txt`
+  );
+  return new Promise((resolve4) => {
+    let child;
+    try {
+      child = spawn(runner.bin, runner.buildArgs(prompt, outFile), { cwd });
+    } catch (error) {
+      resolve4({ ok: false, error: String(error) });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve4(r);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish({ ok: false, error: `${runner.label} timed out` });
+    }, RUN_TIMEOUT_MS);
+    child.stdout?.on("data", (d) => stdout += d);
+    child.stderr?.on("data", (d) => stderr += d);
+    child.on(
+      "error",
+      (e) => finish({ ok: false, error: String(e.message) })
+    );
+    child.on("close", (code) => {
+      if (code !== 0) {
+        finish({
+          ok: false,
+          error: stderr.trim() || `${runner.label} exited with code ${code}`
+        });
+        return;
+      }
+      void runner.readResult(stdout, outFile).then(
+        (answer) => finish(
+          answer ? { ok: true, answer } : { ok: false, error: `${runner.label} returned nothing` }
+        )
+      );
+    });
+  });
+}
+async function handleAgents(res) {
+  const agents = await detectAgents();
+  res.statusCode = 200;
+  res.setHeader("content-type", "application/json");
+  res.setHeader("cache-control", "no-store");
+  res.end(
+    JSON.stringify({ agents: agents.map(({ id, label }) => ({ id, label })) })
+  );
+}
+function handleAsk(req, res, specFile) {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    res.end();
+    return;
+  }
+  if (!String(req.headers["content-type"] ?? "").includes("application/json")) {
+    res.statusCode = 415;
+    res.end();
+    return;
+  }
+  let body = "";
+  let aborted = false;
+  req.on("data", (chunk) => {
+    if (aborted) return;
+    body += chunk;
+    if (body.length > MAX_BODY_BYTES2) {
+      aborted = true;
+      res.statusCode = 413;
+      res.end();
+      req.destroy();
+    }
+  });
+  req.on("end", async () => {
+    if (aborted) return;
+    const reply = (status, payload) => {
+      res.statusCode = status;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify(payload));
+    };
+    let question;
+    let requested;
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed.question !== "string" || !parsed.question.trim())
+        throw new Error("missing question");
+      question = parsed.question.trim();
+      requested = typeof parsed.agent === "string" ? parsed.agent : void 0;
+    } catch (error) {
+      reply(400, { ok: false, error: String(error.message) });
+      return;
+    }
+    const agents = await detectAgents();
+    if (agents.length === 0) {
+      reply(503, {
+        ok: false,
+        error: "no agent CLI found \u2014 install claude, codex, or kimi"
+      });
+      return;
+    }
+    const runner = agents.find((a) => a.id === requested) ?? agents[0];
+    const prompt = await buildPrompt(specFile, question);
+    const result = await runAgent(runner, prompt, dirname2(specFile));
+    if (result.ok)
+      reply(200, { ok: true, agent: runner.id, answer: result.answer });
+    else reply(502, { ok: false, agent: runner.id, error: result.error });
+  });
+}
+
+// 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;
+  let contact = process.env.ZFRAMES_CONTACT;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--port" || a === "-p") {
+      port = Number(args[++i]);
+    } else if (a.startsWith("--port=")) {
+      port = Number(a.slice("--port=".length));
+    } else if (a === "--contact") {
+      contact = args[++i];
+    } else if (a.startsWith("--contact=")) {
+      contact = a.slice("--contact=".length);
+    } else if (!a.startsWith("-")) {
+      file = a;
+    } else {
+      return { error: `unknown option "${a}"` };
+    }
+  }
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    return { error: "--port must be an integer between 1 and 65535" };
+  }
+  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) {
+    console.error(`\u2717 ${parsed.error}`);
+    console.error(
+      "usage: zframes serve [dashboard.json] [--port <n>] [--contact <email>]"
+    );
+    return Promise.resolve(1);
+  }
+  const file = resolve2(process.cwd(), parsed.file);
+  if (!existsSync2(file) || !statSync2(file).isFile()) {
+    console.error(`\u2717 no dashboard.json at ${parsed.file}`);
+    console.error("  pass a path, or run from a directory that has one.");
+    return Promise.resolve(1);
+  }
+  const userDir = resolve2(file, "..");
+  const bundleDir = fileURLToPath(new URL("../runtime", import.meta.url));
+  if (!existsSync2(join3(bundleDir, "index.html"))) {
+    console.error(`\u2717 runtime bundle missing at ${bundleDir}`);
+    console.error("  run `pnpm build:cli` to build it.");
+    return Promise.resolve(1);
+  }
+  return new Promise((done) => {
+    const server = createServer((req, res) => {
+      const rawPath = (req.url ?? "/").split("?")[0];
+      let path;
+      try {
+        path = decodeURIComponent(rawPath);
+      } catch {
+        res.statusCode = 400;
+        res.end();
+        return;
+      }
+      if (path === DASHBOARD_READ_ROUTE) {
+        if (req.method === "GET" || req.method === "HEAD") {
+          void handleSpecRead(file, res);
+        } else {
+          res.statusCode = 405;
+          res.end();
+        }
+        return;
+      }
+      if (path === DASHBOARD_WRITE_ROUTE) {
+        handleSpecWrite(req, res, file);
+        return;
+      }
+      if (path === AGENTS_LIST_ROUTE) {
+        if (req.method === "GET") {
+          void handleAgents(res);
+        } else {
+          res.statusCode = 405;
+          res.end();
+        }
+        return;
+      }
+      if (path === ASK_ROUTE) {
+        handleAsk(req, res, file);
+        return;
+      }
+      if (path === DASHBOARD_PROXY_ROUTE) {
+        void handleProxy(req, res, {
+          userAgent: parsed.contact ? `zframes (${parsed.contact})` : void 0
+        });
+        return;
+      }
+      if (path.startsWith("/__zframes/")) {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        res.statusCode = 405;
+        res.end();
+        return;
+      }
+      if (tryStatic(bundleDir, path, res)) return;
+      if (path !== "/" && tryStatic(userDir, path, res)) return;
+      sendFile(join3(bundleDir, "index.html"), res);
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(
+          `\u2717 port ${parsed.port} is already in use \u2014 pass --port <n> or stop the other server`
+        );
+      } else {
+        console.error(`\u2717 server error: ${err.message}`);
+      }
+      done(1);
+    });
+    server.listen(parsed.port, "127.0.0.1", () => {
+      const url = `http://127.0.0.1:${parsed.port}`;
+      console.log(`\u25B8 zframes serving ${parsed.file} on ${url}`);
+      console.log("  live editing on \u2014 drag, resize, then Save writes back.");
+      if (!parsed.contact) {
+        console.log(
+          "  tip: pass --contact <email> so SEC/official-data requests identify you (fair-access)."
+        );
+      }
+    });
+  });
+}
+
+// src/snapshot.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+
+// ../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 } = {}) {
+  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 res = await fetch(target, {
+    ...init2,
+    headers,
+    signal: init2?.signal ?? AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) throw new Error(`${url} failed: ${res.status}`);
+  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 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)
+    );
+  }
+};
+
+// ../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 CoinGeckoProvider = class {
+  name = "coingecko";
+  capabilities = ["global-market"];
+  async getGlobalMarket() {
+    const cached = readCache();
+    if (cached && Date.now() - cached.at < TTL_MS) return cached.value;
+    try {
+      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 = {
+        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;
+    }
+  }
+};
+
+// ../provider-defillama/src/index.ts
+var CHAINS_URL = "https://api.llama.fi/v2/chains";
+var DefiLlamaProvider = class {
+  name = "defillama";
+  capabilities = ["tvl"];
+  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 }));
+  }
+};
+
+// ../provider-hyperliquid/src/index.ts
+var WS_URL = "wss://api.hyperliquid.xyz/ws";
+var INFO_URL = "https://api.hyperliquid.xyz/info";
+var dexOf = (symbol) => symbol.includes(":") ? symbol.split(":")[0] : "";
+async function info(body) {
+  return fetchJson(INFO_URL, void 0, {
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }
+  });
+}
+var HyperliquidProvider = class {
+  name = "hyperliquid";
+  capabilities = [
+    "quote-stream",
+    "day-stats",
+    "funding-history",
+    "ohlcv"
+  ];
+  ws = null;
+  listeners = /* @__PURE__ */ new Set();
+  reconnectTimer = null;
+  closedByUser = false;
+  /** Dexes we want an allMids subscription for ("" = default dex). */
+  wantedDexes = /* @__PURE__ */ new Set([""]);
+  /** Dexes actually subscribed on the current socket. */
+  subscribedDexes = /* @__PURE__ */ new Set();
+  /** Latest mids across all dexes, merged. */
+  mergedMids = {};
+  subscribeMids(onMids, symbols) {
+    this.listeners.add(onMids);
+    for (const symbol of symbols ?? []) this.wantedDexes.add(dexOf(symbol));
+    this.ensureSocket();
+    this.subscribeMissingDexes();
+    return () => {
+      this.listeners.delete(onMids);
+      if (this.listeners.size === 0) this.teardown();
+    };
+  }
+  async getDayStats(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 prevDayPx = Number(ctx.prevDayPx);
+          if (!Number.isFinite(markPx) || !Number.isFinite(prevDayPx)) return;
+          out[asset.name] = {
+            markPx,
+            prevDayPx,
+            changePct: prevDayPx ? (markPx - prevDayPx) / prevDayPx * 100 : 0
+          };
+        });
+      })
+    );
+    return out;
+  }
+  async getFundingHistory(symbols, startTimeMs) {
+    const results = await Promise.all(
+      symbols.map(async (coin) => {
+        const entries = await info({
+          type: "fundingHistory",
+          coin,
+          startTime: startTimeMs
+        });
+        const points = entries.map((entry) => ({
+          time: entry.time,
+          fundingRate: Number(entry.fundingRate)
+        })).filter(
+          (point) => Number.isFinite(point.fundingRate) && Number.isFinite(point.time)
+        );
+        return [coin, points];
+      })
+    );
+    return Object.fromEntries(results);
+  }
+  async getCandles(symbol, interval, startTimeMs) {
+    const entries = await info({
+      type: "candleSnapshot",
+      req: { coin: symbol, interval, startTime: startTimeMs }
+    });
+    return entries.map((entry) => ({
+      time: entry.t,
+      open: Number(entry.o),
+      high: Number(entry.h),
+      low: Number(entry.l),
+      close: Number(entry.c),
+      volume: Number(entry.v)
+    }));
+  }
+  ensureSocket() {
+    if (this.ws) return;
+    this.closedByUser = false;
+    this.subscribedDexes = /* @__PURE__ */ new Set();
+    const ws = new WebSocket(WS_URL);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.subscribeMissingDexes();
+    };
+    ws.onmessage = (event) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (msg.channel !== "allMids" || !msg.data?.mids) return;
+      for (const [symbol, px] of Object.entries(msg.data.mids))
+        this.mergedMids[symbol] = Number(px);
+      for (const listener of this.listeners) listener(this.mergedMids);
+    };
+    ws.onclose = () => {
+      this.ws = null;
+      if (!this.closedByUser && this.listeners.size > 0) {
+        this.reconnectTimer = setTimeout(() => this.ensureSocket(), 2e3);
+      }
+    };
+  }
+  subscribeMissingDexes() {
+    const ws = this.ws;
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    for (const dex of this.wantedDexes) {
+      if (this.subscribedDexes.has(dex)) continue;
+      const subscription = { type: "allMids" };
+      if (dex) subscription.dex = dex;
+      ws.send(JSON.stringify({ method: "subscribe", subscription }));
+      this.subscribedDexes.add(dex);
+    }
+  }
+  teardown() {
+    this.closedByUser = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+    this.ws = null;
+    this.subscribedDexes = /* @__PURE__ */ new Set();
+    this.mergedMids = {};
+  }
+};
+
+// src/snapshot.ts
+var DAY_MS = 864e5;
+function loadSpec(file) {
+  let raw;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    console.error(`\u2717 cannot read ${file}`);
+    return null;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    console.error(`\u2717 ${file} is not valid JSON: ${error.message}`);
+    return null;
+  }
+  const parsed = DashboardSpecSchema.safeParse(json);
+  if (!parsed.success) {
+    console.error(`\u2717 ${file} is not a valid dashboard spec:`);
+    for (const issue of parsed.error.issues)
+      console.error(`  ${issue.path.join(".") || "(root)"}: ${issue.message}`);
+    return null;
+  }
+  return parsed.data;
+}
+function symbolsFromSpec(spec) {
+  const set = /* @__PURE__ */ new Set();
+  for (const instance of spec.frames) {
+    const cfg = instance.config;
+    if (typeof cfg.symbol === "string") set.add(cfg.symbol);
+    if (Array.isArray(cfg.symbols)) {
+      for (const sym of cfg.symbols) if (typeof sym === "string") set.add(sym);
+    }
+  }
+  return [...set];
+}
+async function safe(label, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    console.error(`  \xB7 ${label} unavailable: ${error.message}`);
+    return null;
+  }
+}
+function rankMovers(stats, count) {
+  const rows = Object.entries(stats).map(([symbol, stat]) => ({
+    symbol,
+    changePct: stat.changePct,
+    markPx: stat.markPx
+  })).filter((row) => row.markPx > 0).sort((a, b) => b.changePct - a.changePct);
+  return {
+    gainers: rows.slice(0, count),
+    losers: rows.slice(-count).reverse()
+  };
+}
+function flagValue(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function runMeta(args) {
+  const pick = (flag, env) => flagValue(args, flag) ?? process.env[env] ?? null;
+  const rawConfig = pick("--config", "ZFRAMES_CONFIG");
+  let config = rawConfig;
+  if (typeof rawConfig === "string") {
+    try {
+      config = JSON.parse(rawConfig);
+    } catch {
+      config = rawConfig;
+    }
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    model: pick("--model", "ZFRAMES_MODEL"),
+    effort: pick("--effort", "ZFRAMES_EFFORT"),
+    config
+  };
+}
+function loadPriorEntry(dashboardPath, logFlag) {
+  const logPath = logFlag ? resolve3(logFlag) : resolve3(dirname3(dashboardPath), "..", "public", "daily-analysis.json");
+  if (!existsSync3(logPath)) return null;
+  try {
+    const json = JSON.parse(readFileSync(logPath, "utf8"));
+    const entries = json.entries ?? [];
+    return entries.length ? entries[entries.length - 1] : null;
+  } catch {
+    return null;
+  }
+}
+async function snapshot(args) {
+  const file = args.find((arg) => !arg.startsWith("--"));
+  if (!file) {
+    console.error(
+      "usage: zframes snapshot <dashboard.json> [--log <file>] [--date YYYY-MM-DD]\n         [--model <id>] [--effort <level>] [--config <json>]  (or ZFRAMES_MODEL / ZFRAMES_EFFORT / ZFRAMES_CONFIG env)"
+    );
+    return 1;
+  }
+  const logFlag = flagValue(args, "--log");
+  const dateFlag = flagValue(args, "--date");
+  const spec = loadSpec(file);
+  if (!spec) return 1;
+  const universe = symbolsFromSpec(spec);
+  const featured = universe[0] ?? null;
+  const hl = new HyperliquidProvider();
+  const now = Date.now();
+  const [userStats, marketStats, candles, funding, fearGreed, global, tvl] = await Promise.all([
+    universe.length ? safe("hyperliquid day-stats", () => hl.getDayStats(universe)) : Promise.resolve({}),
+    safe("hyperliquid market universe", () => hl.getDayStats()),
+    featured ? safe(
+      "hyperliquid candles",
+      () => hl.getCandles(featured, "1d", now - 14 * DAY_MS)
+    ) : Promise.resolve(null),
+    universe.length ? safe(
+      "hyperliquid funding",
+      () => hl.getFundingHistory(universe.slice(0, 6), now - 3 * DAY_MS)
+    ) : Promise.resolve({}),
+    safe("fear & greed", () => new AlternativeMeProvider().getFearGreed(14)),
+    safe("global market", () => new CoinGeckoProvider().getGlobalMarket()),
+    safe("tvl", () => new DefiLlamaProvider().getTvlByChain())
+  ]);
+  const out = {
+    date: dateFlag ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    run: runMeta(args),
+    universe,
+    featured,
+    market: {
+      dayStats: userStats,
+      topMovers: marketStats ? rankMovers(marketStats, 5) : null,
+      candles,
+      funding,
+      fearGreed,
+      global,
+      tvl: tvl ? tvl.slice(0, 12) : null
+    },
+    priorEntry: loadPriorEntry(file, logFlag)
+  };
+  console.log(JSON.stringify(out, null, 2));
+  return 0;
+}
+
+// src/index.ts
+var HELP = `zframes \u2014 AI-personalizable market dashboards
+
+usage:
+  zframes init [dir|file]     write a bare, valid dashboard.json (envelope only \u2014
+                              version, author, grid, background, theme, empty
+                              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
+                              (--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)
+  zframes lint <file>         validate a dashboard.json; exit 1 with readable
+                              errors (the agent's self-correction feedback)
+  zframes snapshot <file>     gather a keyless market snapshot for the symbols
+                              on <dashboard.json> + the prior brief, as JSON on
+                              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 {
+    raw = readFileSync2(file, "utf8");
+  } catch {
+    console.error(`\u2717 cannot read ${file}`);
+    return 1;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    console.error(`\u2717 ${file} is not valid JSON: ${error.message}`);
+    return 1;
+  }
+  const parsed = DashboardSpecSchema.safeParse(json);
+  if (!parsed.success) {
+    console.error(`\u2717 ${file} is not a valid dashboard spec:`);
+    for (const issue of parsed.error.issues)
+      console.error(`  ${issue.path.join(".") || "(root)"}: ${issue.message}`);
+    return 1;
+  }
+  const issues = lintSpec(parsed.data);
+  if (issues.length > 0) {
+    console.error(`\u2717 ${file} has ${issues.length} issue(s):`);
+    for (const issue of issues)
+      console.error(`  [${issue.frameId ?? "spec"}] ${issue.message}`);
+    return 1;
+  }
+  console.log(
+    `\u2713 ${file} is valid \u2014 ${parsed.data.frames.length} frame(s) on a ${parsed.data.grid.columns}-column grid`
+  );
+  return 0;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const [command, arg] = args;
+  switch (command) {
+    case "init":
+      return init(args.slice(1));
+    case "catalogue":
+      console.log(JSON.stringify(catalogueForAI(frameMetas), null, 2));
+      return 0;
+    case "lint":
+      if (!arg) {
+        console.error("usage: zframes lint <dashboard.json>");
+        return 1;
+      }
+      return lint(arg);
+    case "serve":
+      return serve(args.slice(1));
+    case "snapshot":
+      return snapshot(args.slice(1));
+    case "help":
+    case void 0:
+      console.log(HELP);
+      return 0;
+    default:
+      console.error(`unknown command "${command}"
+`);
+      console.log(HELP);
+      return 1;
+  }
+}
+main().then((code) => process.exit(code));
+export {
+  lintSpec
+};