OmniFin Portal

A Next.js 14 (App Router) + Tailwind CSS finance portal.

• Module 1 — Converters: a cross-asset Universal Currency Converter (36 fiat currencies + 12 cryptocurrencies + 5 precious/base metals, any asset to any other, searchable pickers, rate matrix), a Metals & Commodities Calculator covering Gold, Silver, Platinum, Palladium, Copper (all auto-filled from live spot prices, by weight unit and — for gold — karat) and Crude Oil (auto-filled, priced per barrel), and a worldwide unit converter (length, area, weight, volume, speed, digital storage, temperature — including Tola, Maund, Seer, Marla and Kanal), all tabbed together with programmatic SEO routes for both currency pairs and unit pairs.
• Module 4 — Calculators Hub (/calculators): seven free calculators across two category tabs — Trading Tools (Position & Lot Size, Pip Value, Risk/Reward Ratio, Margin & Leverage) and Wealth & Personal Finance (Inflation & Purchasing Power, Compound Interest / Wealth Growth, Business Profit Margin & Markup). The same calculators are also embedded as compact "quick mini-widgets" inside relevant Academy lessons and Converter pages. See "Notes on the Calculators Hub" below for the full breakdown.
• Module 3 — OmniFin Academy (/learn): a free, gamified, BabyPips-style "School of Pipsology" curriculum — 5 skill levels (Rookie → Apprentice → Analyst → Strategist → Pro Trader), 20 bite-sized lessons, 100 quiz questions total, visual SVG diagram cards, two OmniFin tools embedded directly inside relevant lessons, and localStorage-backed progress tracking with level unlocking. See "Notes on the OmniFin Academy" below for the full breakdown.
• Module 2 — Market AI & News: a clean Market Analysis page — a top ticker-tape strip (S&P 500, Nasdaq 100, Gold, BTC/USD, EUR/USD), a full interactive TradingView Advanced Chart with a symbol picker, and an on-demand rule-based "AI Technical Analysis" panel with a visual Buy/Sell/Neutral meter, three bias widgets (Technical Bias, Fundamental Bias, Overall Market Sentiment), and a full report (Price Action, Support/Resistance, Pivot Points, Oscillators) plus an additive Fibonacci or Gann Theory section — computed live from /api/rates, zero paid API dependency — all with a light/dark toggle; and a categorized Financial News page (Forex / Crypto / Commodities / Stocks) with search, category filters, rule-based Bullish/Bearish/Neutral sentiment badges per headline tagged by which asset(s) it's about, a per-asset sentiment breakdown card, and a Social Buzz Tracker (clearly labeled simulated chatter intensity/sentiment across X/Twitter and Reddit, with a disabled "use live API" toggle) (AI summaries and real social-listening data are both placeholders until an Anthropic API key / social data source is configured).

Stack

• Next.js 14 (App Router, React 18)
• Tailwind CSS 3
• A unified rates API fetching Fiat (ExchangeRate-API), Crypto (CoinGecko), Metals (metals-api.com, 5 assets incl. Copper) and Commodities (Crude Oil, static reference price for now) in parallel via Promise.all(), each with its own timeout and fallback, cached with ISR-style 3600s (1 hour) revalidation (app/api/rates/route.js)
• A separate RSS news aggregator route spanning 7 feeds across 4 categories (Stocks, Forex, Crypto, Commodities), same timeout/fallback pattern, cached for 900s (app/api/news-ai/route.js)
• TradingView public embed widgets (no API key required) — the "Advanced Chart" widget for the detailed chart and the lighter-weight "Mini Symbol Overview" widget for the Global Markets Overview grid
• Tailwind's class-based dark mode (darkMode: "class") opted into locally by the Market Analysis page's own light/dark toggle, rather than site-wide

Getting started

npm install
npm run dev

Open http://localhost:3000.

Project structure

app/
  api/
    rates/route.js            # Thin JSON wrapper around lib/marketData.js
    market-ai/route.js        # On-demand technical analysis (rule-based; see lib/technicalAnalysis.js)
    news-ai/route.js          # Thin JSON wrapper around lib/newsAggregator.js
  converters/
    page.jsx                  # Tabbed directory (Currency / Metals & Commodities / Units) + featured pairs
    [pair]/page.jsx           # Programmatic SEO routes across fiat/crypto/metals, e.g. usd-to-pkr,
                                # btc-to-usd, xau-to-usd — JSON-LD (FinancialProduct + WebApplication)
    unit/[slug]/page.jsx      # Programmatic SEO routes, e.g. sqft-to-marla
  market-analysis/
    page.jsx                  # Ticker strip + full chart + AI Technical Analysis panel (light/dark)
    ai-news/page.jsx          # Redirects to /ai-news (legacy path, kept for old links)
  ai-news/
    page.jsx                  # Categorized Financial News page (search + category pills + sentiment)
  learn/
    page.jsx                  # Academy hub shell (metadata) wrapping components/academy/AcademyHub.jsx
    [level]/[lesson]/page.jsx # One lesson page (generateStaticParams over all 20 lessons),
                                # wrapping components/academy/LessonViewer.jsx
  calculators/
    page.jsx                  # Calculators Hub shell (metadata) wrapping components/calculators/CalculatorsHub.jsx
  community/
    page.jsx                  # Community Forum shell (metadata) wrapping components/community/CommunityHub.jsx
  about/
    page.jsx                  # About Us — purpose, educational/utility mandate, data transparency
  disclaimer/
    page.jsx                  # Financial Disclaimer — "educational only, not financial advice"
  privacy/
    page.jsx                  # Privacy Policy — AdSense-required disclosures
  terms/
    page.jsx                  # Terms of Service — AdSense-required disclosures
  sitemap.js                  # Next.js sitemap convention -> served at /sitemap.xml
  robots.js                   # Next.js robots convention -> served at /robots.txt
  layout.jsx                  # Header, nav, footer (footer now links About/Privacy/Terms/Disclaimer/Sitemap)
  page.jsx                    # Homepage dashboard
  globals.css
components/
  CurrencyConverter.jsx       # Cross-asset converter: Fiat/Crypto/Metals, swap, rate matrix
  ConverterStructuredData.jsx # JSON-LD (FinancialProduct + WebApplication) for a converter SEO page
  PopularPairs.jsx             # "Popular Currency & Metal Pairs" cross-linking block
  ConvertersTabs.jsx          # Tab shell switching Currency / Metals & Commodities / Units
  GoldCalculator.jsx          # Metals & Commodities calculator (6-asset selector; auto-fills
                                # live spot prices; uses lib/conversionMath) — filename kept
                                # for history, the component/UI is no longer gold-only
  UnitConverter.jsx           # Universal multi-category unit converter
  TradingChart.jsx            # TradingView "Advanced Chart" embed wrapper (allows symbol change)
  TickerStrip.jsx             # TradingView "Ticker Tape" embed wrapper — the top horizontal strip
  MiniSymbolWidget.jsx        # TradingView "Mini Symbol Overview" embed wrapper (currently unused
                                # by MarketOverviewBoard.jsx; kept as a reusable building block)
  MarketOverviewBoard.jsx     # Ticker strip + MarketDashboard + AiTechnicalAnalysis, light/dark toggle
  MarketDashboard.jsx         # Symbol picker (global indices) + TradingChart
  AiTechnicalAnalysis.jsx     # On-demand instrument + analysis-type picker, calls /api/market-ai;
                                # renders the meter, the 3 bias cards and the full report sections
  SentimentMeter.jsx          # Visual 5-segment Strong Sell..Strong Buy gauge bar (pure rendering
                                # of a score already computed in lib/technicalAnalysis.js)
  NewsFeed.jsx                 # Client-side search + category filter + sentiment + asset-tag badges
  academy/
    AcademyHub.jsx             # Progress banner + level roadmap grid + search/category filter
    LessonViewer.jsx           # Renders one lesson's sections, sticky nav, and the QuizModule
    QuizModule.jsx             # End-of-module quiz engine — instant feedback, 80% pass threshold,
                                # score card with "Retake Quiz" / "Proceed to Next Chapter"
    LessonVisualCard.jsx       # ~13 reusable inline-SVG diagram kinds (candlestick,
                                # support-resistance, risk-reward, bid-ask, MA crossover, RSI,
                                # Fibonacci, timeline, comparison, flow, gauge, grid, ladder)
    EmbeddedTool.jsx           # toolId -> real OmniFin tool component registry (used inside lessons)
    MiniLotSizeCalculator.jsx  # Small position-sizing calculator embedded in two lessons
    CourseSidebar.jsx          # Sticky current-level header + progress tracker + clickable
                                # lesson list on the lesson page (desktop, lg breakpoint+)
  calculators/
    CalculatorsHub.jsx         # Category tabs (Trading Tools / Wealth & Personal Finance) + calculator grid
    MiniCalculatorWidget.jsx   # calculatorId -> full calculator component, embedded in Academy lessons
                                # (via academy/EmbeddedTool.jsx) and Converter pages
    LotSizeCalculator.jsx      # Position & Lot Size Calculator (Standard/Mini/Micro breakdown)
    PipValueCalculator.jsx     # Pip Value Calculator (live-rate USD/PKR conversion)
    RiskRewardCalculator.jsx   # Risk/Reward Ratio Calculator (works for any asset, not just forex)
    MarginCalculator.jsx       # Margin & Leverage Calculator (1:50 to 1:500, plus custom)
    InflationCalculator.jsx    # Inflation & Purchasing Power Calculator
    CompoundGrowthCalculator.jsx # Compound Interest / Wealth Growth Calculator (year-by-year table)
    ProfitMarginCalculator.jsx # Business Profit Margin & Markup Calculator
  community/
    CommunityHub.jsx           # Stats header + category tabs + search/asset-pill filters + feed
    TradePostCard.jsx          # One post: avatar, direction badge, Entry/Target/SL, illustrative
                                # chart placeholder + "Expand Setup" modal, vote/Bullseye counters
    CreatePostModal.jsx        # "Share Trade Setup / Insight" trigger + form, submits via
                                # hooks/useCommunityPosts.js's addPost()
    Modal.jsx                  # Reusable fixed-overlay modal shell (first true overlay modal in
                                # this codebase; used by both CreatePostModal and the Expand Setup view)
lib/
  formatNumber.js              # Shared, safely-clamped Intl.NumberFormat wrapper used by every
                                # number formatter in the project — see "Notes on number
                                # formatting safety" below
  conversionMath.js           # All conversion math (weight/karat metals pricing,
                                # flat-unit commodity pricing, units + temperature)
  currencies.js                # Master fiat currency list + fallback rates
  crypto.js                    # Master cryptocurrency list + fallback USD prices
  metals.js                    # Master metals list (incl. Copper) + fallback USD/troy-oz prices
  commodities.js               # Crude Oil (barrel-priced) — deliberately separate from metals.js
  marketData.js                # getUnifiedRates() — the actual Fiat+Crypto+Metals+Commodities
                                # fetch/fallback logic, called directly by app/api/rates/route.js
                                # AND app/api/market-ai/route.js (no self-fetch — see its header)
  technicalAnalysis.js         # Rule-based technical-analysis engine behind /api/market-ai —
                                # instrument registry, round-level math, the Buy/Sell/Neutral
                                # SCORE_LABEL_BANDS, Technical/Fundamental/Overall Bias, Pivot
                                # Points, Fibonacci, and the honest RSI/EMA & Gann Theory
                                # degradation (see its header comment)
  assetConversion.js           # Cross-asset "convert anything to anything" engine
  unitSlugs.js                # URL-slug <-> unit mapping for SEO routes
  fxSlugs.js                   # URL-slug <-> currency-pair mapping for SEO routes (fiat-only;
                                # still used by app/converters/page.jsx's directory listing)
  pairSlugs.js                 # URL-slug <-> asset-pair mapping across fiat/crypto/metals (superset
                                # of fxSlugs.js), used by app/converters/[pair]/page.jsx
  siteUrl.js                    # Resolves an absolute site URL for metadata/JSON-LD
  fetchRates.js                # Client-side caller for /api/rates (GoldCalculator)
  newsAggregator.js            # The actual RSS fetch/parse/fallback/sentiment logic — called
                                # directly by app/ai-news/page.jsx, not over HTTP
  fetchNews.js                 # Client-side-only caller for /api/news-ai (unused
                                # server-side — see comment in the file for why)
  academyData.js                # OmniFin Academy curriculum — 5 levels, 20 lessons, 100 quiz
                                # questions, plus pure helper functions (getLevel, getLesson,
                                # getAdjacentLessons, getLevelStats, ...) — no React/browser APIs
  calculatorsRegistry.js        # CALCULATOR_CATEGORIES + CALCULATORS metadata — single source of
                                # truth shared by CalculatorsHub.jsx and MiniCalculatorWidget.jsx
  tradingCalculators.js         # Pure math: calculateLotSize, calculatePipValue, calculateRiskReward,
                                # calculateMargin — no React, no fetch, fully unit-testable
  personalCalculators.js        # Pure math: calculateInflation, calculateCompoundGrowth,
                                # calculateMarginMarkup — no React, no fetch
  communityData.js              # Community Forum categories, asset tags, bias options, and 9
                                # seeded/illustrative posts — no React/browser APIs (see its
                                # header comment on why this seed data is clearly non-authoritative)
hooks/
  useAcademyProgress.js         # localStorage-backed Academy progress: completed lessons, quiz
                                # scores, level-unlock logic, overall % — see its header comment
  useCommunityPosts.js          # localStorage-backed Community Forum state: user-submitted posts,
                                # per-post vote/Bullseye toggle state — see its header comment on
                                # why votes are stored as toggle state, not accumulated counts

Environment variables

Copy .env.example to .env.local:

cp .env.example .env.local

• EXCHANGE_RATE_API_KEY (optional) — a key from exchangerate-api.com enables the higher-limit v6 endpoint for fiat rates. Without a key, the route falls back to the free open.er-api.com endpoint, and finally to static rates if both are unreachable, so the app always renders. The older name EXCHANGERATE_API_KEY is still read as a fallback.
• COINGECKO_API_KEY (optional) — a free "Demo" key from coingecko.com raises the rate limit for crypto prices. Without a key, requests go through anonymously (lower limit, fine at this traffic level).
• METALS_API_KEY (optional) — a key from metals-api.com enables live gold/silver/ platinum/palladium/copper spot prices from that provider. If it's missing, or the call fails for any reason (wrong plan, a base currency restriction, bad/expired key, quota spent), the route automatically falls back to api.gold-api.com, a free, keyless provider, so metal prices stay live either way — note that gold-api.com itself doesn't support copper (XCU), so a metals-api.com outage with no key configured drops copper specifically to its static fallback even while gold/silver/platinum/palladium stay live. Only if both providers are unreachable does it drop to static fallback numbers for that asset class — fiat and crypto are unaffected regardless. See "Notes on the unified rates API" below for how to read the metalsDebug field when diagnosing a METALS_API_KEY issue.
• Crude oil (WTI, in commodities) has no live provider wired in yet — no free, keyless spot-price API was found for it, and the usual providers (e.g. oilpriceapi.com) require a paid/trial key. It always returns a static reference price (lib/commodities.js), and the response's commodityNote field says so explicitly — this is surfaced separately from the top-level warnings array so it never falsely flips the Metals & Commodities Calculator's "live rates connected" badge to "fallback" when fiat/crypto/metals are all genuinely live. Add an OIL_API_KEY-style variable and a fetchFromOilApi() tier in fetchCommodityPrices() (app/api/rates/route.js) to wire in a real feed later.

Notes on number formatting safety

• The bug: Intl.NumberFormat (and Number.prototype.toLocaleString, which calls it) throws a RangeError — "maximumFractionDigits value is out of range" — whenever minimumFractionDigits ends up greater than maximumFractionDigits, or either one is NaN/undefined, or either falls outside the valid 0-100 range. Several formatters in this project called toLocaleString with one of those two options hardcoded and the other passed through from a caller-supplied decimals argument. That's exactly what broke the Vercel build: components/calculators/PipValueCalculator.jsx's formatContractSize() called its local formatNumber(units, 0) for whole-number contract sizes (100,000; 10,000; … down to 1), against a helper that hardcoded minimumFractionDigits: 2 — max: 0, min: 2 throws. This only renders for the Pip Value Calculator's dropdown, which Next.js statically prerenders on /calculators directly and on any /converters/[pair] page that embeds it as a mini-widget (any pair involving a fiat currency, e.g. /converters/usd-to-pkr — see app/converters/[pair]/page.jsx's relatedCalculatorId logic) — a server-side render, so the thrown error failed the build instead of just showing a client-side fallback.
• The fix: one shared, defensively-clamped wrapper, lib/formatNumber.js's formatNumber(value, options). It returns "—" for any non-finite value (including NaN, undefined, Infinity, or a non-number), clamps maximumFractionDigits to [0, 20] (rounding first, defaulting to 2 if missing/NaN) — a deliberately tighter ceiling than the engine's actual 0-100 allowance, since no formatter in this project ever legitimately needs more than a handful of decimal places and a lower cap is one more layer of defense — and clamps minimumFractionDigits to [0, safeMax] — i.e. it can never exceed the already-clamped maximum, which is the exact constraint the bug violated. Every formatter in the project — GoldCalculator.jsx, CurrencyConverter.jsx, UnitConverter.jsx, lib/conversionMath.js, lib/technicalAnalysis.js, AiTechnicalAnalysis.jsx, app/converters/[pair]/page.jsx, every calculator under , and — now delegates to this one function instead of calling directly or hand-rolling its own clamp (two of them, and , had already hit and fixed a sibling version of this same bug once before with their own local clamps; those are now just thin wrappers around the shared one instead of duplicating it).

Notes on the Metals & Commodities Calculator math

• Covers 6 assets via a single "Metal / Commodity" dropdown: Gold (XAU), Silver (XAG), Platinum (XPT), Palladium (XPD), Copper (XCU) and Crude Oil (WTI) — components/GoldCalculator.jsx's ASSET_OPTIONS. Switching assets re-syncs the base price field to that asset's live spot price (data.metals[code] or data.commodities.WTI) and discards any value the user had typed in for the previous asset, since a manually-edited gold price has no meaning once silver is selected.
• Gold/Silver/Platinum/Palladium/Copper (weight-based, via calculateGoldPrice()):
  • Base input is USD price per troy ounce.
  • Weight units convert via grams: 1 troy oz = 31.1034768 g, 1 tola = 11.6638038 g, 1 kg = 1000 g.
  • Karat purity (24K / 22K) only applies to Gold — the other four assets are always priced at full/100% purity; the Karat selector is hidden for them.
  • Local price = (USD/oz ÷ 31.1034768) × karat purity × exchange rate × grams-per-unit × quantity.
• Crude Oil (barrel-based, via calculateFlatUnitPrice()): no weight unit or karat step at all — local price = USD/barrel × exchange rate × quantity (in barrels). The weight-unit dropdown is hidden when Crude Oil is selected.
• All of the above lives in lib/conversionMath.js so the Metals & Commodities Calculator and any future component can reuse the same formulas. Crude oil's "USD per unit" is intentionally a different convention (per barrel, not per troy ounce) from the metals — see the comment at the top of lib/commodities.js for why it's kept in its own registry rather than merged into lib/metals.js.

Notes on the unit converter

• Every category (length, area, weight, volume, speed, digital storage) is defined as a flat factor relative to one base unit, so conversion is a single multiply/divide — see UNIT_CATEGORIES in lib/conversionMath.js.
• Temperature is handled separately with explicit Celsius/Fahrenheit/ Kelvin formulas, since those scales aren't simple multiples.
• lib/unitSlugs.js maps short URL slugs (sqft, marla, km, kg…) to { category, unit } pairs, powering /converters/unit/[slug] (e.g. /converters/unit/sqft-to-marla). FEATURED_UNIT_PAIRS there is pre-rendered at build time via generateStaticParams; any other valid <from>-to-<to> slug still resolves on demand.

Notes on the unified rates API

app/api/rates/route.js fetches four independent sources in parallel with Promise.all() and returns one unified JSON shape:

{
  "base": "USD",
  "fiat":   { "USD": 1, "PKR": 278.5, "EUR": 0.92, "...": "..." },
  "crypto": { "BTC": 65234.12, "ETH": 3456.78, "SOL": 142.33, "...": "..." },
  "metals": { "XAU": 2634.50, "XAG": 30.85, "XPT": 912.40, "XPD": 985.10, "XCU": 0.31 },
  "commodities": { "WTI": 75 },
  "sources": { "fiat": "exchangerate-api.com (v6)", "crypto": "coingecko.com", "metals": "metals-api.com", "commodities": "static-fallback" },
  "fetchedAt": "2026-10-09T18:00:00.000Z",
  "revalidateSeconds": 3600,
  "warnings": ["Metal prices unavailable (...); using fallback values."],
  "commodityNote": "Live crude oil pricing isn't wired in yet (no provider configured) — showing a static reference price."
}

Conventions (see the long comment at the top of the route file and in lib/assetConversion.js for the full reasoning):

• fiat keeps the traditional FX convention: "units of X per 1 USD" (so fiat.USD is always 1).
• crypto and metals are both "direct USD value of 1 unit" (1 BTC in USD; 1 troy ounce of gold in USD) — metals-api.com actually quotes metals the same way fiat does (ounces per 1 USD), so the route inverts it server-side before returning, specifically so metals and crypto share one convention and the Metals & Commodities Calculator can use metals.XAU directly as "USD per troy ounce" with no extra math.
• commodities is also "direct USD value of 1 unit," but the unit is a barrel, not a troy ounce — a deliberately different meaning from metals, which is why crude oil lives in its own lib/commodities.js registry and response field rather than being folded into metals (that would silently break the Currency Converter's cross-asset math, which assumes every metals.* value is per troy ounce).

Each provider call:

• Has its own try/catch and own static fallback (lib/currencies.js's FALLBACK_RATES, lib/crypto.js's CRYPTO_FALLBACK_USD, lib/metals.js's METAL_FALLBACK_USD, lib/commodities.js's COMMODITY_FALLBACK_USD) — one provider being down or rate-limited never breaks the others, it just adds an entry to the top-level warnings array and keeps serving fallback numbers for that asset class only.
• Has an 8-second hard timeout via AbortController (cachedFetch() in the route file), so a slow/hanging upstream can't stall the whole route — this is also what was crashing static prerendering once before (see the formatAmount/maximumFractionDigits fix below); the timeout guards against a different, request-level failure mode.
• Metals specifically has a 3-tier chain, not just keyed → static: fetchFromMetalsApi() (metals-api.com, needs METALS_API_KEY) → fetchFromGoldApi() (api.gold-api.com, free, no key — supports gold/silver/platinum/palladium but not copper) → METAL_FALLBACK_USD (static). A metals-api.com failure that gets rescued by gold-api.com is still live data, so it does not add to warnings (which the UI treats as "showing stale numbers") — instead the reason metals-api.com was skipped is put in a separate, non-UI metalsDebug field on the response (e.g. curl your-deployment.vercel.app/api/rates or the Vercel function logs), so a misconfigured key is diagnosable without the Metals & Commodities Calculator ever showing an incorrect "fallback" badge for data that's actually live.
• Commodities specifically (fetchCommodityPrices()) is, for now, always a static reference price — no live crude-oil provider is wired in (see the Environment Variables section above). This is a by-design, permanent state rather than a degradation, so unlike the other three sources it does not contribute to the top-level warnings array (that would falsely show "fallback" on every single request even when fiat/crypto/metals are all genuinely live). Instead it's surfaced as its own commodityNote field — the same separation-of-concerns pattern as metalsDebug above.

Notes on the Universal Currency Converter

• lib/assetConversion.js is the cross-asset engine: it normalizes every asset (fiat, crypto, or metal) to "USD value of 1 unit" via getUsdValue(), so converting any asset to any other asset is always just amount * usdValue(from) / usdValue(to) — implemented in convertBetweenAssets(). This is how Fiat→Fiat, Crypto→Fiat, Metal→Crypto, etc. all work through one code path.
• lib/currencies.js (36 fiat currencies), lib/crypto.js (12 major cryptocurrencies, with their CoinGecko ids), and lib/metals.js (5 metals — gold, silver, platinum, palladium, copper) are the three asset registries this converter draws on. Add an asset to any one of them and it's immediately available in the converter's picker, in /api/rates, and (for fiat) in the SEO routes. (Crude oil, in lib/commodities.js, is deliberately not included here — it's barrel-priced rather than weight-priced, so folding it into this "USD per unit" cross-asset engine would need its own conversion path; it's wired into the Metals & Commodities Calculator only, for now.)
• components/CurrencyConverter.jsx implements its own searchable, grouped dropdown (a text input + filtered list with Fiat/Crypto/ Metals section headers) rather than a native <select>, since plain selects can't be typed into to filter options or show groups.
• The 24h trend badge is an intentionally labeled placeholder — no historical rate store exists yet. See the TODO comment in CurrencyConverter.jsx's TrendBadge for how to wire in a real percentage once day-over-day rates are persisted somewhere.
• lib/fxSlugs.js maps <from>-to-<to> slugs (e.g. usd-to-pkr) to fiat currency codes for /converters/[pair] — the SEO route is fiat-only by design (that's what people search for), but the converter component it renders also lets the visitor switch either side to crypto or metals once the page loads. Next.js App Router folder names only support a single dynamic segment each, so this route lives at app/converters/[pair]/page.jsx rather than a literal [from]-to-[to] folder — the resulting URLs are identical either way. It sits safely alongside the separate app/converters/unit/[slug] route because Next.js always matches a literal folder name (unit) before a dynamic one at the same level.
• components/GoldCalculator.jsx (the Metals & Commodities Calculator) auto-fills its "Base Price" field from the selected asset's live spot price (metals.XAU//// or ) on load and whenever a different asset is selected, but only until the user types their own value (tracked via a ref to avoid a stale-closure bug where the auto-fill could re-trigger after a manual edit); hitting "Refresh rates" resets that and re-syncs to the live price.

Notes on Market Analysis & AI News

• app/market-analysis/page.jsx renders components/MarketOverviewBoard.jsx, which has its own local light/dark toggle (not tied to OS preference or any site-wide setting — see darkMode: "class" in tailwind.config.js) and is now three stacked sections instead of the old 15-widget grid:

  1. components/TickerStrip.jsx — TradingView's free "Ticker Tape" embed widget, a slim scrolling strip of 5 high-value universal symbols: S&P 500, Nasdaq 100, Gold, BTC/USD, EUR/USD. Purpose-built for exactly this "clean top bar" case, instead of stacking several Mini Symbol Overview cards side by side.
  2. components/MarketDashboard.jsx — unchanged: a symbol quick-pick row + TradingChart.jsx's full "Advanced Chart" widget (allowSymbolChange: true, so a visitor can also search for any other instrument inside the chart itself).
  3. components/AiTechnicalAnalysis.jsx — the new "On-Demand AI Technical Analysis" panel: pick an instrument and an analysis type, hit "Run Analysis," and it calls GET /api/market-ai for a structured, live-computed result.

  All symbols across this page (and MarketDashboard.jsx's picker) stick to TradingView families already confirmed safe in two earlier rounds of fixes: direct exchange symbols like NSE:NIFTY/ PSX:KSE100 show "This symbol is only available on TradingView" (gated behind a logged-in account for guest embeds), and a first workaround attempt (AMEX:INDY/AMEX:PAK/CME:NIY1!) turned out to be "Invalid Symbol" entirely (not in TradingView's database at all). The current symbols are all FOREXCOM:/TVC:/OANDA:/BITSTAMP: — broad, globally-recognized, never gated for anonymous embeds.

• app/api/market-ai/route.js + lib/technicalAnalysis.js power the AI Technical Analysis panel. getInstrument()/ resolveInstrumentPrice() resolve a live USD price for one of 15 instruments (5 metals, crude oil, 5 crypto, 4 FX pairs — all backed by real numbers already available from lib/marketData.js's getUnifiedRates(), called directly with no self-fetch, same lesson as lib/newsAggregator.js) from /api/rates's payload. It checks process.env.ANTHROPIC_API_KEY; absent (or present but not yet wired — generateAiAnalysis() is a documented stub), it falls through to 's rule-based engine, which returns the full report (, the default) — / just add one extra section on top, they don't replace it:

Notes on programmatic SEO converter routes & structured data

• app/converters/[pair]/page.jsx now resolves <from>-to-<to> slugs across all three asset classes — fiat, crypto, metals — not just FX: /converters/usd-to-pkr, /converters/btc-to-usd, /converters/xau-to-usd all work through the same route. lib/pairSlugs.js's parsePairSlug() resolves each side's code against CURRENCY_CODES/CRYPTO_CODES/METAL_CODES in turn (no collisions between the three sets — verified) and returns null for anything unrecognized, which triggers notFound(). lib/fxSlugs.js is unchanged and still powers app/converters/page.jsx's existing fiat-only "Popular Currency Pairs" directory listing — pairSlugs.js is a separate, additive superset used only by the dynamic route.
• The page is now an async Server Component that calls getUnifiedRates() directly (via lib/marketData.js, no self-fetch — same architectural lesson as lib/newsAggregator.js) to resolve a live rate for this specific pair via getPairRate() (lib/assetConversion.js). That rate feeds both the page's "1 X = Y" summary line and the JSON-LD below; if it's genuinely unavailable, both simply omit it rather than guessing — the client-side CurrencyConverter component still renders and fetches its own live rate independently either way.
• generateMetadata() builds a per-pair title/description, alternates.canonical, and openGraph/twitter tags from lib/siteUrl.js's getSiteUrl() (falls back through NEXT_PUBLIC_SITE_URL → VERCEL_URL → localhost:3000, same chain lib/fetchRates.js already used internally).
• components/ConverterStructuredData.jsx renders one <script type="application/ld+json"> with an "@graph" of two entities:
  • A FinancialProduct describing the specific pair, with additionalProperty PropertyValues for the base/quote asset, their classes, and — only when a live rate was actually resolved server-side — exchangeRate and exchangeRateAsOf. No aggregateRating/review fields are included anywhere, since this project has no real review data to back one (same never-fabricate-structured-data bar as the rest of this project).

Notes on the OmniFin Academy

• Curriculum (lib/academyData.js): 5 skill levels, mirroring BabyPips' "School of Pipsology" progression — Rookie (Foundations of Money & Wealth: inflation, money vs. fiat, fractional reserve banking, gold vs. paper money), Apprentice (Market Mechanics & Charting: candlestick anatomy, bid/ask spreads, pips & lot sizes, order types), Analyst (Technical Precision & Indicators: support/resistance, RSI, moving averages, Fibonacci, Gann basics), Strategist (Macro Fundamentals & Sentiment: central bank rates, NFP & news trading, market sentiment), and Pro Trader (Risk Management & Psychology: position sizing math, risk-to-reward, trading journal, FOMO/greed). 20 lessons total, 100 quiz questions total (5 per lesson) — verified by a standalone Node script asserting every quiz has 4-5 questions, every correctOptionId actually exists among that question's options, no duplicate level/lesson/question IDs, and that lesson adjacency correctly crosses level boundaries (e.g. Rookie's last lesson's "next" is Apprentice's first).
• Each lesson is a list of typed sections — text (heading + body
  • optional bullet list), proTip (emerald-accent highlighted callout), risk (rose-accent risk-warning callout — leverage, revenge trading, moved stops, and other genuinely dangerous habits, not just a generic "be careful"), formula (blue-accent key-formula/ concept card), visual (a diagram card), and tool (an embedded OmniFin calculator) — rendered generically by components/academy/LessonViewer.jsx, so adding a new lesson is a pure data change in lib/academyData.js, no new component code. 3 lessons (Position Sizing Math, Risk-to-Reward Ratio, Controlling FOMO & Greed) got a risk section added in natural, already-relevant spots rather than being retrofitted everywhere.
• components/academy/LessonVisualCard.jsx is a toolkit of ~13 reusable, parameterized inline-SVG diagram kinds — candlestick, support-resistance, risk-reward, bid-ask, ma-crossover, rsi, fibonacci, timeline, comparison, flow, gauge, grid, ladder — rather than one hand-drawn image per lesson. Each lesson's diagram spec just picks a kind and supplies small data (e.g. { kind: "risk-reward", riskUnits: 1, rewardUnits: 2 }), which keeps every diagram genuinely illustrative of its concept (candlestick anatomy, a support/resistance breakout, a 1:2 risk-reward setup, etc.) without needing bespoke artwork per lesson.

Dark theme redesign & the Master Path / Focused Track architecture fix

• A permanently dark theme, not a toggle. The whole Academy (app/learn/**) now renders on a fixed dark palette — bg-ink (#0b0f19, a new token added in tailwind.config.js) for the page background, Tailwind's own gray-900 (#111827, an exact match for the requested glassmorphic-card color) for cards, and gray-800 (#1f2937, an exact match for the requested muted border color) for borders — regardless of the rest of the (light-themed) site. This is deliberately different from the dark:-variant toggle pattern used by components/MarketOverviewBoard.jsx elsewhere in this project: the Academy is always dark, not user-togglable, so its components use plain (non-dark:-prefixed) classes against these fixed tokens.
• A fixed 3-color semantic accent system, used identically across the hub and every lesson page: Electric Blue (blue-500/#3b82f6 — an exact match for Tailwind's own default blue-500) for primary CTAs and the reading-progress stepper; Emerald (emerald-500/ #10b981, also an exact Tailwind default) for pro-tips and mastered/correct states; Soft Rose (rose-500/#f43f5e, also exact) for risk warnings and incorrect/failing states. No new color tokens were needed for these three — they're exact matches for Tailwind's stock palette, confirmed before using them.
• components/academy/LessonVisualCard.jsx's 13 diagram kinds were recolored for legibility against the new dark cards (labels and structural lines that were tuned for a white background — e.g. #64748b, #334155, #1e293b, #e2e8f0 — became lighter/darker dark-appropriate equivalents), while the semantic colors (bull green, bear red, the formula-line blue/gold) were left as-is since they already read fine on dark. The diagram "stage" inside each Frame is a recessed bg-black/25 panel on the gray-900 card, the same look used for every other dark card on this page.
• components/academy/EmbeddedTool.jsx now frames each embedded calculator in a dark gray-900/gray-800 card rather than recoloring the calculator itself — those tools (GoldCalculator, MiniLotSizeCalculator, the MiniCalculatorWidget registry) are shared components also used on their own light-themed pages elsewhere (the homepage, the Calculators Hub), so changing their internal colors here would have changed how they look everywhere else too. The frame is the same idea as a screenshot not needing to match the color of the page it's embedded in.

Refinement pass: light page body, locked category tracks, course sidebar

A follow-up pass on the dark redesign above, in response to feedback that the fully-dark page body (everywhere, not just the cards) hurt contrast and that removing level-locking entirely from category tracks went further than intended:

• Page body reverted to the site's normal light theme. bg-ink (#0b0f19) is no longer the page background anywhere — AcademyHub.jsx and LessonViewer.jsx's outer wrappers, header/breadcrumb sections, and plain paragraph text (TextSection) are back to the same light slate/white/brand palette as every other page on the site. ink stays defined in tailwind.config.js, but is now used only for the floating dark widget chrome that's meant to visibly "pop" over the light page — the lesson page's sticky top progress bar and sticky bottom prev/next nav.
• Callout cards changed from translucent tints to solid dark cards. ProTip/RiskWarning/FormulaBadge in LessonViewer.jsx previously used e.g. bg-emerald-500/10 with no opaque base — that read as a dark glass card only because the page behind it was also dark. Now that the page is light, the same translucent tint would wash out into a pale, washed-looking card instead of a "sleek dark" one. Fixed by giving each an explicit opaque bg-gray-900 base with a colored border/glow on top, matching the same solid-card treatment LevelCard/FocusedTrackCard (AcademyHub.jsx) and QuizModule.jsx already used — so every card still reads as genuinely dark regardless of what's behind it.
• Category tracks are locked again, plus a new always-unlocked Overview card. The previous pass made every category-track lesson frictionlessly clickable regardless of level progress; this walks that back — a category track (Forex/Metals/Crypto/Technicals/ Personal Finance) now applies the same level-unlock gating as the Master Path (locked lessons render grayed-out with a 🔒 and are not links), so advanced, level-specific modules genuinely stay behind normal progression. The one addition: selecting a category tab (with no search query) always shows one extra, always-unlocked "Overview / Basic Introduction" card first, with the exact requested banner ("This is a basic overview. To unlock full deep-dive modules for this topic, complete the core levels starting from Level 1.") and a "Start Level 1" link. This card is new content (CATEGORY_OVERVIEWS in lib/academyData.js), not a link to a real lesson page — verified against the actual curriculum data that this is necessary, not decorative: with fresh (no) progress, the Forex track's 12 lessons are all locked (0 of 12 unlocked), so without this card a new visitor clicking "Forex" would see a wall of locked cards and no way to learn anything about the topic at all.
• New sticky Course Sidebar () on the lesson page: the current level's header, an in-level progress tracker (lessons completed / total + percent bar), and a clickable vertical list of every lesson in that level, with the current lesson highlighted and completed ones check-marked. Every row is clickable — locks and unlocks whole , not individual lessons within an already-unlocked level (there's no "lesson 3 is locked until lesson 2 is done" concept in this curriculum), and already refuses to render this component at all when the current level itself is locked — so by the time the sidebar appears, every lesson it lists is a legitimate, already-unlocked destination. It's below the breakpoint and sticks () alongside the lesson content on larger screens; on mobile the existing sticky Previous/Next bottom bar remains the way to move between lessons.

Second refinement: slate color tokens, every card clickable, and a Locked Module modal

A further refinement on the pass above, in response to feedback that (a) specified the dark-card tokens as Tailwind's slate scale rather than gray, and (b) asked for every category-track card to be clickable regardless of lock status, with locked ones opening a modal instead of rendering as a non-clickable grayed-out card:

• gray-* → slate-* across every Academy dark-card token. AcademyHub.jsx, LessonViewer.jsx, CourseSidebar.jsx, QuizModule.jsx, LessonVisualCard.jsx, and EmbeddedTool.jsx all switched their card backgrounds/borders/text from gray-900/gray-800/ etc. (#111827/#1f2937) to slate-900/slate-800/etc. (#0f172a/#1e293b) to match the requested tokens exactly — same relative lightness relationship (card background darker than its border) preserved throughout, so nothing lost contrast in the swap. The two sticky floating widgets on the lesson page (the top progress bar and the bottom prev/next nav) moved off the old one-off ink token (#0b0f19, still defined in tailwind.config.js but now unused) onto bg-slate-900/95 too, for one consistent dark-chrome color across the whole module. The light page body/container wrappers stay bg-slate-50 (#f8fafc) — already an exact match for the requested light background — and the category/search switcher bar now sits on a bg-slate-100 (#f1f5f9) strip, so both requested light tokens are visibly in use, not just the paler of the two.
• Every category-track card is now clickable — no more non-clickable grayed-out cards, and no more separate always-unlocked "Overview" card. AcademyHub.jsx's FocusedTrackCard previously rendered a locked lesson as a cursor-not-allowed <div>; it's now a real <button> that opens a LockedModuleModal with the lesson's topic and level, a short "Basic Concept & Introduction" built from CATEGORY_OVERVIEWS (lib/academyData.js) plus a line naming the specific locked lesson, and the exact requested CTA: "🔒 Full Deep-Dive Module Locked. Complete the foundational levels starting from Level 1: Rookie to unlock the complete interactive lesson & quiz." — plus a "Start Level 1: Rookie →" shortcut. The previous pass's standalone, always-unlocked CategoryOverviewCard is removed entirely now that its content lives in the modal instead. Unlocked cards are unchanged — a normal Link straight to the real lesson.
• The modal reuses the existing shared overlay shell (components/community/Modal.jsx) — built originally for the Community Forum's "Share Trade Setup" flow and "Expand Setup" detail view — rather than a new, Academy-specific modal component. It's deliberately left in that component's normal light styling (matching every other modal already in the app) rather than recolored dark, since a locked-module detail popover reads more like the rest of the light chrome (a tooltip/detail view) than like one of the dark "cards" the brief calls out by name.

Clean-up pass: drop the Locked Module modal, restore plain "🔒 Locked" cards

A clean-up on the pass directly above, reverting its modal-based locked-card treatment back to a simpler, plainly-marked lock state:

• FocusedTrackCard is non-clickable again when locked, and the LockedModuleModal/Modal import are both removed from AcademyHub.jsx entirely — a locked category-track card is back to a plain <div> (not a <button>, not a <Link>) carrying an explicit "🔒 Locked" badge, the same badge language LevelCard already uses on the Master Path, so the lock state now reads identically in every view instead of category tracks opening a modal while the Master Path shows a static badge.
• Lock rules are unchanged (this was never actually altered by any earlier pass): Level 1 (Rookie) is unlocked from the start, and every later level — on the Master Path and inside a category track alike — stays locked until every lesson in the previous level is mastered, per hooks/useAcademyProgress.js's isLevelUnlocked.
• Two-column lesson layout now uses an explicit 4-column CSS grid (LessonViewer.jsx's grid grid-cols-1 lg:grid-cols-4) instead of a flex row, so the sidebar/reader split is literally 1 column of 4 for CourseSidebar.jsx (lg:col-span-1) and 3 of 4 for the main reader (lg:col-span-3) — same sticky behavior and content as before, just expressed as a grid to match that exact proportion. Stacks to a single column below the lg breakpoint, same as previously.
• Page body/background untouched — already bg-slate-50 (#f8fafc) with only the cards/widgets dark, from the previous pass; nothing to change here.
• Verification: bracket-balance checked via /tmp/balcheck.py across all three edited files, and a fresh Node simulation against the real lib/academyData.js confirming the lock-gating facts are still exactly as before: Level 1 is order 1 and unlocked by default; the Forex track still has 12 lessons, all 12 locked with fresh progress (0 unlocked); 20 lessons total; and getLevel/ getLevelStats still resolve correctly for Level 2. All checks passed with 0 failures.

Notes on the Calculators Hub

• lib/tradingCalculators.js and lib/personalCalculators.js hold all the math for the seven calculators as plain, dependency-free functions (no React, no fetch) — calculateLotSize, calculatePipValue, calculateRiskReward, calculateMargin, calculateInflation, calculateCompoundGrowth, and calculateMarginMarkup. Each returns null on invalid/incomplete input rather than a misleading NaN-filled result, matching the pattern established by MiniLotSizeCalculator.jsx. Verified end-to- end with a standalone Node script exercising every function with known numbers (e.g. a $10,000 account risking 1% with a 20-pip stop at $10/pip → exactly 0.5 standard lots / 5 mini / 50 micro; a 50-pip risk vs. 100-pip reward → exactly a 1:2 ratio; $50,000 notional at 1:100 leverage on a $1,000 account → exactly $500 required margin and a 200% margin level).

• Position & Lot Size Calculator: the same formula as the Academy's MiniLotSizeCalculator.jsx (Lot Size ≈ Risk Amount ÷ (Stop-Loss Pips × Pip Value per Lot)), extended to also report the Mini (×10) and Micro (×100) lot equivalents.

• Pip Value Calculator: a dropdown of 31 real, named tradable instruments (lib/tradingCalculators.js's TRADABLE_PAIRS), grouped into four <optgroup>s by PAIR_CATEGORIES:

  • Forex — majors & minors (EUR/USD, GBP/USD, USD/JPY, AUD/USD, USD/CAD, USD/CHF, NZD/USD), crosses (EUR/GBP, EUR/JPY, GBP/JPY, AUD/JPY, NZD/JPY), and regional PKR pairs (USD/PKR, EUR/PKR, GBP/PKR, AED/PKR, SAR/PKR).
  • Commodities & Metals — XAU/USD (Gold), XAG/USD (Silver), XPT/USD (Platinum), XCU/USD (Copper), WTI/USD (Crude Oil), BRENT/USD (Brent Oil).
  • Indices — US30 (Dow Jones), US500 (S&P 500), NAS100 (Nasdaq), GER40 (DAX — the only instrument quoted in EUR rather than USD, which exercises the same live-rate conversion as everything else rather than assuming USD).
  • Crypto — BTC/USD, ETH/USD, SOL/USD, XRP/USD, BNB/USD.

  Pip/tick/point precision and contract size both auto-detect from the pair's instrumentType (seven of them: forex, forex-jpy, forex-pkr, metal, energy, index, crypto), each with its own genuinely-different convention rather than one borrowed from forex: for standard FX; for JPY pairs and for PKR-quoted pairs (PKR's larger nominal value puts its pip at the 2nd decimal, the same reasoning as JPY); a user-selectable -or- for metals and energy (both conventions are genuinely in use across brokers); a user-selectable -or- point for indices; and a single, explicitly-labeled-as-non-standard tick for crypto. Switching pairs always resets the pip/tick selector to the new pair's own default. Contract size per lot is equally instrument-specific () — 100,000/10,000/1,000 units for every forex variant, 100/10/1 troy ounces for metals, 1,000/100/10 barrels for energy, and a 1/0.1/0.01 stand-in scale for both indices and crypto (labeled in the UI as this calculator's own scale, not an exchange standard, since neither has one). Pip value in the quote currency () is converted live to USD and PKR using the same unified, hourly-cached rates payload every other calculator on the platform reads ( / ), with a visible live/fallback status dot and a safe fallback-rate table () if the live fetch fails — never a blank result, and never a build-time crash either (see "Notes on number formatting safety" above for the RangeError this combination caused during SSG before the fix). Verified with a Node script covering all 31 instruments × all 3 lot sizes (93 combinations, none throwing, every USD/PKR conversion finite) plus spot-checks (EUR/USD → exactly $10/pip on a standard lot; USD/PKR → correctly computed in PKR then converted through the live PKR/USD rate; GER40 → correctly computed in EUR, not silently assumed as USD; WTI/USD → $10/pip on a 1,000-barrel standard lot; ETH/USD micro → $0.01 on a 0.01 ETH stand-in contract).

Notes on the Community Forum

• app/community/page.jsx + components/community/CommunityHub.jsx: same thin-server-shell/"use client"-body split used by the Academy and Calculators modules — the server shell exports metadata, the client component owns the interactive state (category tabs, search, asset-tag filter pills, the post feed, and the "Share Trade Setup / Insight" trigger).
• Seed data is explicitly illustrative, not live activity. lib/communityData.js ships 9 seeded posts spanning all four categories ("Trade Setups & Ideas", "Macro & News Speculation", "Financial Literacy") and all four asset tags (#Gold, #Forex, #Crypto, #Indices). The forum's stats header is honest about this:
  • Active Traders and Shared Setups are genuinely derived counts over the visible post data (unique author handles; posts with a Long/Short bias) — real arithmetic on demo data, not invented numbers.
  • Accuracy Rate has no backend that tracks whether any posted Entry/Target/Stop Loss actually played out, so rather than fabricate a percentage, the card reads "Not tracked yet" with a footnote explaining why — the same no-fabrication discipline as the Social Buzz Tracker's persistent "Simulated" badge and the Pip Value Calculator's non-standard-instrument disclaimers.
• No real chart images exist anywhere in this app. Each TradePostCard.jsx renders an inline-SVG "chart preview" whose squiggle is deterministically derived from a seeded hash of the post's id (and nudged by its Long/Short bias), so the same post always renders the same squiggle instead of jittering on every re-render — but it is permanently labeled "Illustrative only — not a real chart" directly on the preview, both in the feed and in the "Expand Setup" modal. It is never presented as real market data.
• First true overlay modal in this codebase. components/community/Modal.jsx is a position: fixed backdrop + centered panel (Escape-to-close, backdrop-click-to-close, body-scroll lock) — distinct from academy/QuizModule.jsx's inline "ScoreCard" swap, which is not an overlay. It's reused by both CreatePostModal.jsx (the post-submission form) and TradePostCard.jsx's "Expand Setup" detail view.
• Votes and the "Bullseye Setup" tag are toggle state, not accumulating counters. hooks/useCommunityPosts.js persists only the current browser's own choice per post ("up"/"down"/none for votes, a boolean for Bullseye) in localStorage, following the same SSR-safe hydration pattern as (safe empty state on the server, hydrated from storage after mount). The displayed count is always , computed fresh on every render — so clicking the same button again toggles it back off, and reloading the page shows the same count as before rather than one that keeps climbing. This was a deliberate design choice to avoid a trivial exploit (a visitor inflating a count forever just by refreshing and re-clicking).

Notes on Compliance, Legal Pages & Dynamic SEO Indexing

• Four static legal/compliance pages (app/about, app/disclaimer, app/privacy, app/terms), each a plain server component — no "use client" split needed, since there's no interactive state — styled consistently with the rest of the site (breadcrumb nav, gradient header section, max-w-3xl prose body).

  • About Us states OmniFin Portal's educational/utility mandate up front and is explicit about what's real vs. simulated/rule-based across the site (rates, technical analysis, Social Buzz Tracker, Community Forum chart placeholders, aggregated news) — the same no-fabrication convention already used throughout the product, now written down as a user-facing policy rather than just an in-UI label.
  • Financial Disclaimer is the load-bearing page: an explicit, unambiguous "nothing on this site is financial, investment, trading, legal, or tax advice" banner up top, plus numbered sections covering no-warranty-on-data, simulated/illustrative content, user-generated Community Forum content, past-performance, trading risk, and limitation of liability.
  • Privacy Policy and Terms of Service cover the standard set Google AdSense requires — cookies/advertising, third-party data providers, analytics, children's privacy, acceptable use, intellectual property, and limitation of liability — and are specific about a real architectural detail: Academy progress and Community Forum vote/Bullseye/post state live only in the visitor's own browser's localStorage and are never transmitted to a server, which both policies state plainly rather than describing a generic "we may collect..." data flow that doesn't match how the app actually works.
  • All four pages cross-link each other (About → Disclaimer → Privacy → Terms) so a reader lands on the right policy regardless of which one they opened first.

• app/sitemap.js uses Next.js's built-in sitemap file convention (a default-exported function returning {url, lastModified, changeFrequency, priority} entries), served automatically at /sitemap.xml — no hand-written XML template. It lists every static route (including the four new legal pages) plus every dynamic route that's actually pre-rendered at build time, reusing each route's own generateStaticParams() source list rather than a separate hard-coded copy, so the sitemap can never silently drift out of sync with what's really pre-rendered:

  • /converters/[pair] — lib/pairSlugs.js's FEATURED_PAIRS (14 pairs)
  • /converters/unit/[slug] — 's (12 pairs)

Roadmap

• Phase 3 (planned): Simulators module — ROI calculator, budget planner (Recharts-based), client-side only.
• Phase 4 (planned): SEO content (educational articles), sitemap generation, Google Search Console submission, AdSense application.