refactor: split into idx-core library and idx-cli binary workspace

Phase 2 of docs/DESIGN.md, no behavior change:

- crates/idx-core (library): api, analysis, cache, config file handling
  and provider selection, curl_impersonate, error, ownership, runtime,
  plus the shared test fixtures. clap derives are behind an optional
  `clap` feature so the library does not require clap.
- crates/idx-cli (binary `idx`): cli/, output/, and IdxConfig (output
  format and color resolution). Package and binary names are unchanged.
- config.rs is split: file read/write and validation move to core; a
  CLI test keeps core's OUTPUT_VALUES in sync with OutputSetting.
- ownership::db::open_db/db_path drop their unused IdxConfig argument.
- One workspace version; shared dependency versions; no third-party
  version changes in Cargo.lock. LICENSE is symlinked into each crate.
- flake: workspace version, new source paths, and a per-crate package
  check (idx-cli is built from its tarball against packaged idx-core,
  since idx-core is not on crates.io yet). CI cache key, release path
  filter, and the golden whitespace-hook exclusion follow the new layout.

Parity: all 143 golden outputs match byte for byte without
regeneration; 157 core + 17 CLI unit tests (173 before plus the new
OUTPUT_VALUES sync test), 62 CLI tests pass. Live A/B against main:
16/16 stocks cases identical; ownership discover got IDX 403 on both
(exit 4 vs 1 is the phase 1 exit-code change).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/idx-core/src/api/msn/bing.rs

@@ -0,0 +1,406 @@
+//! Bing Finance institutional ownership HTTP client.
+//!
+//! Provides access to 5 ownership signal endpoints from the Bing hedge fund data
+//! provider API. Each endpoint returns a list of institutional holders grouped by
+//! signal type (holders, buyers, sellers, new positions, exits).
+//!
+//! # Usage
+//! ```rust,ignore
+//! use crate::api::msn::bing::{BingEndpoint, fetch_all_ownership};
+//!
+//! // Fetch all 5 signals for BBCA (instrument ID bn91jc)
+//! let results = fetch_all_ownership("bn91jc", false)?;
+//! for (signal, holders) in results {
+//!     println!("{:?}: {} rows", signal, holders.len());
+//! }
+//! ```
+
+use std::time::Duration;
+
+use crate::error::IdxError;
+use crate::ownership::types::{BingHolderRaw, FlowSignal};
+
+/// Base URL for the Bing hedge fund data provider API.
+const BING_OWNERSHIP_BASE: &str =
+    "https://services.bingapis.com/contentservices-finance.hedgefunddataprovider/api/v1";
+
+/// Browser-like User-Agent matching existing MSN client pattern.
+const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 \
+    (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+
+// ── Endpoint enum ────────────────────────────────────────────────────────────
+
+/// Bing ownership API endpoint variants.
+///
+/// Each variant maps to one Bing hedge-fund endpoint path and the
+/// [`FlowSignal`] it represents in the domain model.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BingEndpoint {
+    /// Existing top institutional holders.
+    TopShareHolders,
+    /// Net buyers over the most recent reporting period.
+    TopBuyers,
+    /// Net sellers over the most recent reporting period.
+    TopSellers,
+    /// Institutions that opened a new position this period.
+    TopNewShareHolders,
+    /// Institutions that fully exited their position this period.
+    TopExitedShareHolders,
+}
+
+impl BingEndpoint {
+    /// URL path segment used in the Bing API request.
+    ///
+    /// The full URL is constructed as:
+    /// `{BING_OWNERSHIP_BASE}/{path}/{instrument_id}`
+    pub fn path(&self) -> &'static str {
+        match self {
+            Self::TopShareHolders => "GetSecurityTopShareHolders",
+            Self::TopBuyers => "GetSecurityTopBuyers",
+            Self::TopSellers => "GetSecurityTopSellers",
+            Self::TopNewShareHolders => "GetSecurityTopNewShareHolders",
+            Self::TopExitedShareHolders => "GetSecurityTopExitedShareHolders",
+        }
+    }
+
+    /// The [`FlowSignal`] this endpoint represents.
+    pub fn signal(&self) -> FlowSignal {
+        match self {
+            Self::TopShareHolders => FlowSignal::Holder,
+            Self::TopBuyers => FlowSignal::Buyer,
+            Self::TopSellers => FlowSignal::Seller,
+            Self::TopNewShareHolders => FlowSignal::NewPosition,
+            Self::TopExitedShareHolders => FlowSignal::Exited,
+        }
+    }
+
+    /// All endpoint variants in a canonical order.
+    pub fn all() -> &'static [BingEndpoint] {
+        &[
+            Self::TopShareHolders,
+            Self::TopBuyers,
+            Self::TopSellers,
+            Self::TopNewShareHolders,
+            Self::TopExitedShareHolders,
+        ]
+    }
+}
+
+// ── HTTP helpers ─────────────────────────────────────────────────────────────
+
+/// Build a `ureq::Agent` with timeouts matching existing MSN client conventions.
+fn build_agent() -> ureq::Agent {
+    ureq::Agent::config_builder()
+        .timeout_connect(Some(Duration::from_secs(5)))
+        .timeout_recv_body(Some(Duration::from_secs(10)))
+        .build()
+        .into()
+}
+
+/// Wrapper type used to handle both bare-array and wrapped-object responses
+/// from the Bing API. Some endpoints may return `[...]` directly, others may
+/// wrap in `{ "value": [...] }` or similar.  We first try bare Vec, then
+/// fall back to the wrapper.
+#[derive(Debug, serde::Deserialize)]
+#[serde(untagged)]
+enum BingResponse {
+    /// Direct JSON array of holder objects.
+    Array(Vec<BingHolderRaw>),
+    /// Object wrapper with a nested array under a common key.
+    Wrapped(BingWrappedResponse),
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct BingWrappedResponse {
+    /// `value` key used by some Bing OData-style responses.
+    #[serde(alias = "value", alias = "Value", alias = "data", alias = "Data")]
+    items: Option<Vec<BingHolderRaw>>,
+}
+
+impl BingResponse {
+    fn into_holders(self) -> Vec<BingHolderRaw> {
+        match self {
+            BingResponse::Array(v) => v,
+            BingResponse::Wrapped(w) => w.items.unwrap_or_default(),
+        }
+    }
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+/// Fetch ownership data from a single Bing endpoint.
+///
+/// `instrument_id` is the MSN instrument identifier (for example `bn91jc` for BBCA).
+/// Use [`crate::api::msn::symbols::resolve_msn_id`] to obtain this from a ticker code.
+///
+/// Empty responses (valid HTTP 200 with empty array) are returned as `Ok(vec![])`.
+/// This is expected for some IDX stocks that Bing does not cover.
+///
+/// # Errors
+/// Returns [`IdxError::Http`] on network or non-retriable HTTP errors.
+/// Returns [`IdxError::RateLimited`] after exhausting retries on 429.
+/// Returns [`IdxError::ParseError`] if the response body cannot be deserialized.
+pub fn fetch_holders(
+    instrument_id: &str,
+    endpoint: &BingEndpoint,
+    verbose: bool,
+) -> Result<Vec<BingHolderRaw>, IdxError> {
+    let url = format!("{BING_OWNERSHIP_BASE}/{}/{instrument_id}", endpoint.path());
+
+    if verbose {
+        eprintln!("[bing] GET {url}");
+    }
+
+    let agent = build_agent();
+    let endpoint_name = endpoint.path();
+    let mut wait = Duration::from_millis(500);
+
+    for attempt in 0..3 {
+        let response = agent
+            .get(&url)
+            .header("User-Agent", USER_AGENT)
+            .header("Accept", "application/json")
+            .header("Accept-Language", "en-US,en;q=0.9")
+            .header("Origin", "https://www.bing.com")
+            .header("Referer", "https://www.bing.com/")
+            .call();
+
+        match response {
+            Ok(ok) => {
+                let body = ok
+                    .into_body()
+                    .read_to_string()
+                    .map_err(|e| IdxError::Http(format!("bing {endpoint_name}: read body: {e}")))?;
+
+                if body.trim().is_empty() || body.trim() == "null" {
+                    return Ok(vec![]);
+                }
+
+                let parsed: BingResponse = serde_json::from_str(&body)
+                    .map_err(|e| IdxError::ParseError(format!("bing {endpoint_name}: {e}")))?;
+
+                return Ok(parsed.into_holders());
+            }
+            Err(ureq::Error::StatusCode(404)) => {
+                // Instrument not found on Bing — return empty, not an error.
+                return Ok(vec![]);
+            }
+            Err(ureq::Error::StatusCode(429)) => {
+                if attempt < 2 {
+                    std::thread::sleep(wait);
+                    wait *= 2;
+                    continue;
+                }
+                return Err(IdxError::RateLimited);
+            }
+            Err(ureq::Error::StatusCode(code)) if code >= 500 => {
+                if attempt < 2 {
+                    std::thread::sleep(wait);
+                    wait *= 2;
+                    continue;
+                }
+                return Err(IdxError::Http(format!(
+                    "bing {endpoint_name}: status {code}"
+                )));
+            }
+            Err(err) => {
+                return Err(IdxError::Http(format!("bing {endpoint_name}: {err}")));
+            }
+        }
+    }
+
+    Err(IdxError::RateLimited)
+}
+
+/// Fetch all 5 ownership endpoints for a given MSN instrument ID.
+///
+/// Returns results grouped by [`FlowSignal`] in canonical endpoint order:
+/// `Holder`, `Buyer`, `Seller`, `NewPosition`, `Exited`.
+///
+/// Endpoints that return empty data are still included as `(signal, vec![])`.
+///
+/// # Errors
+/// Propagates any non-empty error from [`fetch_holders`].
+pub fn fetch_all_ownership(
+    instrument_id: &str,
+    verbose: bool,
+) -> Result<Vec<(FlowSignal, Vec<BingHolderRaw>)>, IdxError> {
+    let mut results = Vec::with_capacity(5);
+    for endpoint in BingEndpoint::all() {
+        let holders = fetch_holders(instrument_id, endpoint, verbose)?;
+        results.push((endpoint.signal(), holders));
+    }
+    Ok(results)
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ── BingEndpoint::path() ──────────────────────────────────────────────
+
+    #[test]
+    fn test_endpoint_path_top_share_holders() {
+        assert_eq!(
+            BingEndpoint::TopShareHolders.path(),
+            "GetSecurityTopShareHolders"
+        );
+    }
+
+    #[test]
+    fn test_endpoint_path_top_buyers() {
+        assert_eq!(BingEndpoint::TopBuyers.path(), "GetSecurityTopBuyers");
+    }
+
+    #[test]
+    fn test_endpoint_path_top_sellers() {
+        assert_eq!(BingEndpoint::TopSellers.path(), "GetSecurityTopSellers");
+    }
+
+    #[test]
+    fn test_endpoint_path_top_new_share_holders() {
+        assert_eq!(
+            BingEndpoint::TopNewShareHolders.path(),
+            "GetSecurityTopNewShareHolders"
+        );
+    }
+
+    #[test]
+    fn test_endpoint_path_top_exited_share_holders() {
+        assert_eq!(
+            BingEndpoint::TopExitedShareHolders.path(),
+            "GetSecurityTopExitedShareHolders"
+        );
+    }
+
+    // ── BingEndpoint::signal() ────────────────────────────────────────────
+
+    #[test]
+    fn test_endpoint_signal_mapping() {
+        assert_eq!(BingEndpoint::TopShareHolders.signal(), FlowSignal::Holder);
+        assert_eq!(BingEndpoint::TopBuyers.signal(), FlowSignal::Buyer);
+        assert_eq!(BingEndpoint::TopSellers.signal(), FlowSignal::Seller);
+        assert_eq!(
+            BingEndpoint::TopNewShareHolders.signal(),
+            FlowSignal::NewPosition
+        );
+        assert_eq!(
+            BingEndpoint::TopExitedShareHolders.signal(),
+            FlowSignal::Exited
+        );
+    }
+
+    // ── BingEndpoint::all() ───────────────────────────────────────────────
+
+    #[test]
+    fn test_endpoint_all_has_five_variants() {
+        assert_eq!(BingEndpoint::all().len(), 5);
+    }
+
+    #[test]
+    fn test_endpoint_all_covers_all_signals() {
+        use std::collections::HashSet;
+        let signals: HashSet<String> = BingEndpoint::all()
+            .iter()
+            .map(|e| format!("{:?}", e.signal()))
+            .collect();
+        assert!(signals.contains("Holder"));
+        assert!(signals.contains("Buyer"));
+        assert!(signals.contains("Seller"));
+        assert!(signals.contains("NewPosition"));
+        assert!(signals.contains("Exited"));
+    }
+
+    // ── Fixture deserialization ───────────────────────────────────────────
+
+    #[test]
+    fn test_deserialize_holders_fixture() {
+        let json = include_str!("../../../tests/fixtures/bing_holders_bbca.json");
+        let holders: Vec<BingHolderRaw> = serde_json::from_str(json)
+            .expect("bing_holders_bbca.json should deserialize into Vec<BingHolderRaw>");
+        assert!(
+            !holders.is_empty(),
+            "fixture should have at least one holder"
+        );
+        // First holder should have a name
+        assert!(
+            holders[0].investor_name.is_some(),
+            "first holder should have investor_name"
+        );
+    }
+
+    #[test]
+    fn test_deserialize_buyers_fixture() {
+        let json = include_str!("../../../tests/fixtures/bing_buyers_bbca.json");
+        let holders: Vec<BingHolderRaw> = serde_json::from_str(json)
+            .expect("bing_buyers_bbca.json should deserialize into Vec<BingHolderRaw>");
+        assert!(
+            !holders.is_empty(),
+            "fixture should have at least one buyer"
+        );
+    }
+
+    // ── Empty response handling ───────────────────────────────────────────
+
+    #[test]
+    fn test_deserialize_empty_array_is_ok() {
+        let json = "[]";
+        let holders: Vec<BingHolderRaw> = serde_json::from_str(json).expect("empty array is valid");
+        assert!(holders.is_empty());
+    }
+
+    #[test]
+    fn test_bing_response_bare_array() {
+        let json = r#"[
+            {
+                "investorName": "Vanguard Group",
+                "investorType": "Institutional",
+                "sharesHeld": 1234567.0,
+                "reportDate": "2024-12-31"
+            }
+        ]"#;
+        let resp: BingResponse = serde_json::from_str(json).unwrap();
+        let holders = resp.into_holders();
+        assert_eq!(holders.len(), 1);
+        assert_eq!(holders[0].investor_name.as_deref(), Some("Vanguard Group"));
+    }
+
+    #[test]
+    fn test_bing_response_wrapped_value_key() {
+        let json = r#"{
+            "value": [
+                {
+                    "InvestorName": "BlackRock",
+                    "InvestorType": "Institutional",
+                    "SharesHeld": 9876543.0
+                }
+            ]
+        }"#;
+        let resp: BingResponse = serde_json::from_str(json).unwrap();
+        let holders = resp.into_holders();
+        assert_eq!(holders.len(), 1);
+        assert_eq!(holders[0].investor_name.as_deref(), Some("BlackRock"));
+    }
+
+    #[test]
+    fn test_bing_response_wrapped_empty_value() {
+        let json = r#"{ "value": [] }"#;
+        let resp: BingResponse = serde_json::from_str(json).unwrap();
+        let holders = resp.into_holders();
+        assert!(holders.is_empty());
+    }
+
+    #[test]
+    fn test_holder_optional_fields_are_none() {
+        let json = r#"[{"investorName": "Some Fund"}]"#;
+        let holders: Vec<BingHolderRaw> = serde_json::from_str(json).unwrap();
+        assert_eq!(holders.len(), 1);
+        assert!(holders[0].shares_held.is_none());
+        assert!(holders[0].shares_changed.is_none());
+        assert!(holders[0].pct_outstanding.is_none());
+        assert!(holders[0].value.is_none());
+        assert!(holders[0].report_date.is_none());
+    }
+}

crates/idx-core/src/api/msn/client.rs

@@ -0,0 +1,466 @@
+use std::time::Duration;
+
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+
+use crate::error::IdxError;
+
+use super::raw_types::{
+    KeyRatios, MsnQuote, RawChartResponse, RawEarningsResponse, RawEquity, RawFinancialStatement,
+    RawInsight, RawNewsFeed, RawScreenerResponse, RawSentiment, ScreenerFilter, ScreenerOrder,
+    ScreenerRequest,
+};
+use super::symbols::resolve_msn_id;
+use crate::api::types::{Interval, Period};
+
+const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+const MSN_ASSETS_BASE_URL: &str = "https://assets.msn.com/service/";
+const MSN_API_BASE_URL: &str = "https://api.msn.com/msn/v0/pages/finance/";
+// Public API key from MSN Money website (embedded in frontend JS)
+const MSN_API_KEY: &str = "0QfOX3Vn51YCzitbLaRkTTBadtWpgTN8NZLW0C1SEM";
+
+pub(super) struct MsnClient {
+    agent: ureq::Agent,
+}
+
+impl MsnClient {
+    pub(super) fn new() -> Self {
+        let agent: ureq::Agent = ureq::Agent::config_builder()
+            .timeout_connect(Some(Duration::from_secs(5)))
+            .timeout_recv_body(Some(Duration::from_secs(10)))
+            .build()
+            .into();
+
+        Self { agent }
+    }
+
+    fn mock_error() -> Option<IdxError> {
+        if std::env::var("IDX_USE_MOCK_PROVIDER").is_ok() && std::env::var("IDX_MOCK_ERROR").is_ok()
+        {
+            Some(IdxError::ProviderUnavailable)
+        } else {
+            None
+        }
+    }
+
+    fn mock_body(endpoint: &str) -> Option<&'static str> {
+        if std::env::var("IDX_USE_MOCK_PROVIDER").is_err() {
+            return None;
+        }
+
+        Some(match endpoint {
+            "quote" => include_str!("../../../tests/fixtures/msn_quote_bbca.json"),
+            "keyratios" => include_str!("../../../tests/fixtures/msn_keyratios_bbca.json"),
+            "equities" => include_str!("../../../tests/fixtures/msn_profile_bbca.json"),
+            "financialstatements" => {
+                include_str!("../../../tests/fixtures/msn_financials_bbca.json")
+            }
+            "earnings" => include_str!("../../../tests/fixtures/msn_earnings_bbca.json"),
+            "sentiment" => include_str!("../../../tests/fixtures/msn_sentiment_bbca.json"),
+            "insights" => include_str!("../../../tests/fixtures/msn_insights_bbca.json"),
+            "news" => include_str!("../../../tests/fixtures/msn_news_bbca.json"),
+            "screener" => include_str!("../../../tests/fixtures/msn_screener_id_topperfs.json"),
+            "chart" => include_str!("../../../tests/fixtures/msn_chart_bbca_3m.json"),
+            _ => return None,
+        })
+    }
+
+    fn mock_json<T: DeserializeOwned>(endpoint: &str) -> Result<Option<T>, IdxError> {
+        let Some(body) = Self::mock_body(endpoint) else {
+            return Ok(None);
+        };
+
+        serde_json::from_str(body)
+            .map(Some)
+            .map_err(|e| IdxError::ParseError(format!("msn {endpoint}: {e}")))
+    }
+
+    fn get_json<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        symbol: &str,
+        endpoint: &str,
+    ) -> Result<T, IdxError> {
+        if let Some(err) = Self::mock_error() {
+            return Err(err);
+        }
+
+        if let Some(mocked) = Self::mock_json(endpoint)? {
+            return Ok(mocked);
+        }
+
+        let mut wait = Duration::from_millis(500);
+        for attempt in 0..3 {
+            let response = self
+                .agent
+                .get(url)
+                .header("User-Agent", USER_AGENT)
+                .header("Accept", "application/json")
+                .header("Accept-Language", "en-US,en;q=0.9,id;q=0.8")
+                .header("Origin", "https://www.msn.com")
+                .header("Referer", "https://www.msn.com/")
+                .call();
+
+            match response {
+                Ok(ok) => {
+                    return ok
+                        .into_body()
+                        .read_json::<T>()
+                        .map_err(|e| IdxError::ParseError(format!("msn {endpoint}: {e}")));
+                }
+                Err(ureq::Error::StatusCode(404)) => {
+                    return Err(IdxError::SymbolNotFound(symbol.to_string()));
+                }
+                Err(ureq::Error::StatusCode(429)) => {
+                    if attempt < 2 {
+                        std::thread::sleep(wait);
+                        wait *= 2;
+                        continue;
+                    }
+                    return Err(IdxError::RateLimited);
+                }
+                Err(ureq::Error::StatusCode(code)) if code >= 500 => {
+                    if attempt < 2 {
+                        std::thread::sleep(wait);
+                        wait *= 2;
+                        continue;
+                    }
+                    return Err(IdxError::Http(format!("msn {endpoint}: status {code}")));
+                }
+                Err(err) => return Err(IdxError::Http(format!("msn {endpoint}: {err}"))),
+            }
+        }
+        Err(IdxError::RateLimited)
+    }
+
+    fn post_json<B: Serialize, T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &B,
+        symbol: &str,
+        endpoint: &str,
+    ) -> Result<T, IdxError> {
+        if let Some(err) = Self::mock_error() {
+            return Err(err);
+        }
+
+        if let Some(mocked) = Self::mock_json(endpoint)? {
+            return Ok(mocked);
+        }
+
+        let mut wait = Duration::from_millis(500);
+        for attempt in 0..3 {
+            let response = self
+                .agent
+                .post(url)
+                .header("User-Agent", USER_AGENT)
+                .header("Accept", "application/json")
+                .header("Accept-Language", "en-US,en;q=0.9,id;q=0.8")
+                .header("Origin", "https://www.msn.com")
+                .header("Referer", "https://www.msn.com/")
+                .header("Content-Type", "text/plain;charset=UTF-8")
+                .send_json(body);
+
+            match response {
+                Ok(ok) => {
+                    return ok
+                        .into_body()
+                        .read_json::<T>()
+                        .map_err(|e| IdxError::ParseError(format!("msn {endpoint}: {e}")));
+                }
+                Err(ureq::Error::StatusCode(404)) => {
+                    return Err(IdxError::SymbolNotFound(symbol.to_string()));
+                }
+                Err(ureq::Error::StatusCode(429)) => {
+                    if attempt < 2 {
+                        std::thread::sleep(wait);
+                        wait *= 2;
+                        continue;
+                    }
+                    return Err(IdxError::RateLimited);
+                }
+                Err(ureq::Error::StatusCode(code)) if code >= 500 => {
+                    if attempt < 2 {
+                        std::thread::sleep(wait);
+                        wait *= 2;
+                        continue;
+                    }
+                    return Err(IdxError::Http(format!("msn {endpoint}: status {code}")));
+                }
+                Err(err) => return Err(IdxError::Http(format!("msn {endpoint}: {err}"))),
+            }
+        }
+        Err(IdxError::RateLimited)
+    }
+
+    pub(super) fn fetch_quotes(&self, symbol: &str) -> Result<Vec<MsnQuote>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}Finance/Quotes?apikey={MSN_API_KEY}&ids={id}&wrapodata=false"
+        );
+        self.get_json(&url, symbol, "quote")
+    }
+
+    pub(super) fn fetch_key_ratios(&self, symbol: &str) -> Result<Vec<KeyRatios>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url =
+            format!("{MSN_API_BASE_URL}keyratios?apikey={MSN_API_KEY}&ids={id}&wrapodata=false");
+        self.get_json(&url, symbol, "keyratios")
+    }
+
+    pub(super) fn fetch_equities(&self, symbol: &str) -> Result<Vec<RawEquity>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}Finance/Equities?apikey={MSN_API_KEY}&ids={id}&wrapodata=false"
+        );
+        self.get_json(&url, symbol, "equities")
+    }
+
+    pub(super) fn fetch_financial_statements(
+        &self,
+        symbol: &str,
+    ) -> Result<Vec<RawFinancialStatement>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}Finance/Equities/financialstatements?apikey={MSN_API_KEY}&ids={id}&wrapodata=false"
+        );
+        self.get_json(&url, symbol, "financialstatements")
+    }
+
+    pub(super) fn fetch_earnings(&self, symbol: &str) -> Result<RawEarningsResponse, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}Finance/Events/Earnings?apikey={MSN_API_KEY}&ids={id}&wrapodata=false"
+        );
+        self.get_json(&url, symbol, "earnings")
+    }
+
+    pub(super) fn fetch_sentiment(&self, symbol: &str) -> Result<Vec<RawSentiment>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}Finance/SentimentBrowser?apikey={MSN_API_KEY}&cm=id-id&it=web&scn=ANON&ids={id}&wrapodata=false&flightId=INeedDau"
+        );
+        self.get_json(&url, symbol, "sentiment")
+    }
+
+    pub(super) fn fetch_insights(&self, symbol: &str) -> Result<Vec<RawInsight>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url =
+            format!("{MSN_API_BASE_URL}insights?apikey={MSN_API_KEY}&ids={id}&wrapodata=false");
+        self.get_json(&url, symbol, "insights")
+    }
+
+    pub(super) fn fetch_news(&self, symbol: &str, limit: usize) -> Result<RawNewsFeed, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}MSN/Feed/me?$top={limit}&apikey={MSN_API_KEY}&cm=id-id&contentType=article,video,slideshow&it=web&query=ef_stock_{id}&queryType=entityfeed&responseSchema=cardview&scn=ANON&wrapodata=false"
+        );
+        self.get_json(&url, symbol, "news")
+    }
+
+    fn post_screener(
+        &self,
+        url: &str,
+        request: &ScreenerRequest,
+    ) -> Result<RawScreenerResponse, IdxError> {
+        if std::env::var("IDX_USE_MOCK_PROVIDER").is_ok() {
+            if let Some(err) = Self::mock_error() {
+                return Err(err);
+            }
+            if let Some(path) = std::env::var_os("IDX_MOCK_MSN_SCREENER_FIXTURE") {
+                let body = std::fs::read_to_string(path)
+                    .map_err(|e| IdxError::ParseError(format!("msn screener fixture: {e}")))?;
+                let mut response: RawScreenerResponse = serde_json::from_str(&body)
+                    .map_err(|e| IdxError::ParseError(format!("msn screener fixture: {e}")))?;
+                // Model MSN's request-sized batches while preserving its reported
+                // total, so complete-list fetching uses the same path as live data.
+                if let Some(quotes) = response.quote.as_mut() {
+                    quotes.truncate(request.limit);
+                }
+                return Ok(response);
+            }
+        }
+        self.post_json(url, request, "SCREENER", "screener")
+    }
+
+    pub(super) fn fetch_screener(
+        &self,
+        filter: &str,
+        region: &str,
+        limit: Option<usize>,
+    ) -> Result<RawScreenerResponse, IdxError> {
+        let url =
+            format!("{MSN_ASSETS_BASE_URL}Finance/Screener?apikey={MSN_API_KEY}&wrapodata=false");
+        let mut req = ScreenerRequest {
+            filter: vec![
+                ScreenerFilter {
+                    key: filter.to_string(),
+                    key_group: "st_list_".to_string(),
+                    is_range: false,
+                },
+                ScreenerFilter {
+                    key: region.to_string(),
+                    key_group: "st_reg_".to_string(),
+                    is_range: false,
+                },
+            ],
+            order: ScreenerOrder {
+                key: "st_1yr_asc_order".to_string(),
+                dir: "desc".to_string(),
+            },
+            return_value_type: vec!["quote".to_string(), "equity".to_string()],
+            screener_type: "stock".to_string(),
+            limit: limit.unwrap_or(500),
+            page_index: 0,
+        };
+
+        if limit.is_some() {
+            return self.post_screener(&url, &req);
+        }
+        fetch_complete_screener(|limit| {
+            req.limit = limit;
+            self.post_screener(&url, &req)
+        })
+    }
+
+    pub(super) fn fetch_chart(
+        &self,
+        symbol: &str,
+        period: &Period,
+        interval: &Interval,
+    ) -> Result<Vec<RawChartResponse>, IdxError> {
+        let id =
+            resolve_msn_id(symbol).ok_or_else(|| IdxError::SymbolNotFound(symbol.to_string()))?;
+        let chart_type = msn_chart_type(period, interval)?;
+        let url = format!(
+            "{MSN_ASSETS_BASE_URL}Finance/Charts?apikey={MSN_API_KEY}&cm=id-id&ids={id}&type={chart_type}&wrapodata=false"
+        );
+        self.get_json(&url, symbol, "chart")
+    }
+}
+
+fn fetch_complete_screener(
+    mut fetch: impl FnMut(usize) -> Result<RawScreenerResponse, IdxError>,
+) -> Result<RawScreenerResponse, IdxError> {
+    let total_count = |response: &RawScreenerResponse| {
+        response
+            .count
+            .and_then(|count| usize::try_from(count).ok())
+            .ok_or_else(|| IdxError::ParseError("MSN screener omitted a valid total count".into()))
+    };
+    let mut response = fetch(500)?;
+    let count = total_count(&response)?;
+    if response.quote.as_ref().map_or(0, Vec::len) < count {
+        // MSN ignores pageIndex for these lists. Re-request the reported total
+        // instead of silently treating the initial batch as the whole market.
+        response = fetch(count)?;
+    }
+    if response.quote.as_ref().map_or(0, Vec::len) < total_count(&response)? {
+        return Err(IdxError::ParseError(
+            "MSN screener returned an incomplete candidate list".into(),
+        ));
+    }
+    Ok(response)
+}
+
+fn msn_chart_type(period: &Period, interval: &Interval) -> Result<&'static str, IdxError> {
+    if !matches!(interval, Interval::Day) {
+        return Err(IdxError::Unsupported(
+            "MSN charts currently support only --interval 1d for IDX history".into(),
+        ));
+    }
+
+    match period {
+        Period::OneMonth => Ok("1M"),
+        Period::ThreeMonths => Ok("3M"),
+        Period::OneYear => Ok("1Y"),
+        _ => Err(IdxError::Unsupported(
+            "MSN charts currently support --period 1mo, 3mo, or 1y with --interval 1d".into(),
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{fetch_complete_screener, msn_chart_type};
+    use crate::api::msn::raw_types::RawScreenerResponse;
+    use crate::api::types::{Interval, Period};
+    use crate::error::IdxError;
+
+    fn screener_response(count: Option<usize>, returned: usize) -> RawScreenerResponse {
+        serde_json::from_value(serde_json::json!({
+            "count": count,
+            "quote": (0..returned).map(|index| serde_json::json!({
+                "symbol": format!("STOCK{index}"),
+                "price": 100
+            })).collect::<Vec<_>>()
+        }))
+        .expect("valid screener response")
+    }
+
+    #[test]
+    fn full_screener_includes_candidates_beyond_initial_batch() {
+        let response =
+            fetch_complete_screener(|limit| Ok(screener_response(Some(600), limit.min(600))))
+                .expect("complete list");
+        let symbols: Vec<_> = response
+            .quote
+            .unwrap()
+            .into_iter()
+            .map(|quote| quote.symbol.unwrap())
+            .collect();
+        assert_eq!(
+            symbols,
+            (0..600)
+                .map(|index| format!("STOCK{index}"))
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn full_screener_rejects_a_truncated_total_response() {
+        let err = fetch_complete_screener(|_| Ok(screener_response(Some(600), 500)))
+            .expect_err("truncated list must not be ranked as complete");
+        assert!(matches!(err, IdxError::ParseError(_)));
+    }
+
+    #[test]
+    fn full_screener_requires_a_total_count() {
+        let err = fetch_complete_screener(|_| Ok(screener_response(None, 500)))
+            .expect_err("unknown completeness must not be treated as a full list");
+        assert!(matches!(err, IdxError::ParseError(_)));
+    }
+
+    #[test]
+    fn maps_supported_msn_chart_types() {
+        assert_eq!(
+            msn_chart_type(&Period::OneMonth, &Interval::Day).unwrap(),
+            "1M"
+        );
+        assert_eq!(
+            msn_chart_type(&Period::ThreeMonths, &Interval::Day).unwrap(),
+            "3M"
+        );
+        assert_eq!(
+            msn_chart_type(&Period::OneYear, &Interval::Day).unwrap(),
+            "1Y"
+        );
+    }
+
+    #[test]
+    fn rejects_unsupported_msn_chart_types() {
+        let err = msn_chart_type(&Period::ThreeMonths, &Interval::Week).unwrap_err();
+        assert!(matches!(err, IdxError::Unsupported(_)));
+
+        let err = msn_chart_type(&Period::SixMonths, &Interval::Day).unwrap_err();
+        assert!(matches!(err, IdxError::Unsupported(_)));
+    }
+}

crates/idx-core/src/api/msn/mod.rs

@@ -0,0 +1,119 @@
+#[allow(dead_code, clippy::enum_variant_names)]
+#[cfg(feature = "ownership")]
+pub mod bing;
+mod client;
+mod map;
+mod parse;
+mod raw_types;
+mod symbols;
+
+use crate::api::types::{
+    Bar, CompanyProfile, EarningsReport, FinancialStatements, Fundamentals, InsightData, Interval,
+    NewsItem, Period, Quote, SentimentData,
+};
+use crate::api::{
+    EarningsProvider, FinancialsProvider, FundamentalsProvider, HistoryProvider, InsightsProvider,
+    NewsProvider, ProfileProvider, QuoteProvider, ScreenerProvider, SentimentProvider,
+};
+use crate::error::IdxError;
+
+use client::MsnClient;
+use map::{
+    parse_earnings, parse_financial_statements, parse_fundamentals, parse_history, parse_insights,
+    parse_news, parse_profile, parse_quote, parse_screener_results, parse_sentiment,
+};
+
+pub(crate) use parse::{parse_fundamentals_from_str, parse_history_from_str, parse_quote_from_str};
+
+pub struct MsnProvider {
+    client: MsnClient,
+}
+
+impl MsnProvider {
+    pub fn new(_verbose: bool) -> Self {
+        Self {
+            client: MsnClient::new(),
+        }
+    }
+}
+
+impl QuoteProvider for MsnProvider {
+    fn quote(&self, symbol: &str) -> Result<Quote, IdxError> {
+        let quotes = self.client.fetch_quotes(symbol)?;
+        parse_quote(symbol, &quotes)
+    }
+}
+
+impl FundamentalsProvider for MsnProvider {
+    fn fundamentals(&self, symbol: &str) -> Result<Fundamentals, IdxError> {
+        let ratios = self.client.fetch_key_ratios(symbol)?;
+        let quote = self.client.fetch_quotes(symbol)?;
+        parse_fundamentals(&ratios, quote.first())
+    }
+}
+
+impl HistoryProvider for MsnProvider {
+    fn history(
+        &self,
+        symbol: &str,
+        period: &Period,
+        interval: &Interval,
+    ) -> Result<Vec<Bar>, IdxError> {
+        let raw = self.client.fetch_chart(symbol, period, interval)?;
+        parse_history(symbol, &raw)
+    }
+}
+
+impl ProfileProvider for MsnProvider {
+    fn profile(&self, symbol: &str) -> Result<CompanyProfile, IdxError> {
+        let raw = self.client.fetch_equities(symbol)?;
+        parse_profile(symbol, &raw)
+    }
+}
+
+impl EarningsProvider for MsnProvider {
+    fn earnings(&self, symbol: &str) -> Result<EarningsReport, IdxError> {
+        let raw = self.client.fetch_earnings(symbol)?;
+        parse_earnings(symbol, &raw)
+    }
+}
+
+impl FinancialsProvider for MsnProvider {
+    fn financials(&self, symbol: &str) -> Result<FinancialStatements, IdxError> {
+        let raw = self.client.fetch_financial_statements(symbol)?;
+        parse_financial_statements(symbol, &raw)
+    }
+}
+
+impl SentimentProvider for MsnProvider {
+    fn sentiment(&self, symbol: &str) -> Result<SentimentData, IdxError> {
+        let raw = self.client.fetch_sentiment(symbol)?;
+        parse_sentiment(symbol, &raw)
+    }
+}
+
+impl InsightsProvider for MsnProvider {
+    fn insights(&self, symbol: &str) -> Result<InsightData, IdxError> {
+        let raw = self.client.fetch_insights(symbol)?;
+        parse_insights(symbol, &raw)
+    }
+}
+
+impl NewsProvider for MsnProvider {
+    fn news(&self, symbol: &str, limit: usize) -> Result<Vec<NewsItem>, IdxError> {
+        let raw = self.client.fetch_news(symbol, limit)?;
+        parse_news(symbol, &raw)
+    }
+}
+
+impl ScreenerProvider for MsnProvider {
+    fn screener(
+        &self,
+        filter: &str,
+        region: &str,
+        limit: Option<usize>,
+    ) -> Result<Vec<Quote>, IdxError> {
+        let raw = self.client.fetch_screener(filter, region, limit)?;
+        parse_screener_results(&raw)
+    }
+}

crates/idx-core/src/api/msn/parse.rs

@@ -0,0 +1,164 @@
+use super::map::{parse_fundamentals, parse_history, parse_quote};
+use super::raw_types::{KeyRatios, MsnQuote, RawChartResponse};
+use crate::api::types::{Fundamentals, Ohlc, Quote};
+use crate::error::IdxError;
+
+#[cfg_attr(not(test), allow(dead_code))]
+pub(crate) fn parse_quote_from_str(symbol: &str, raw: &str) -> Result<Quote, IdxError> {
+    let quotes: Vec<MsnQuote> =
+        serde_json::from_str(raw).map_err(|e| IdxError::ParseError(e.to_string()))?;
+    parse_quote(symbol, &quotes)
+}
+
+#[cfg_attr(not(test), allow(dead_code))]
+pub(crate) fn parse_fundamentals_from_str(
+    raw: &str,
+    quote_raw: Option<&str>,
+) -> Result<Fundamentals, IdxError> {
+    let ratios: Vec<KeyRatios> =
+        serde_json::from_str(raw).map_err(|e| IdxError::ParseError(e.to_string()))?;
+    let quote = quote_raw
+        .map(serde_json::from_str::<Vec<MsnQuote>>)
+        .transpose()
+        .map_err(|e| IdxError::ParseError(e.to_string()))?
+        .and_then(|quotes| quotes.into_iter().next());
+    parse_fundamentals(&ratios, quote.as_ref())
+}
+
+#[cfg_attr(not(test), allow(dead_code))]
+pub(crate) fn parse_history_from_str(symbol: &str, raw: &str) -> Result<Vec<Ohlc>, IdxError> {
+    let charts: Vec<RawChartResponse> =
+        serde_json::from_str(raw).map_err(|e| IdxError::ParseError(e.to_string()))?;
+    parse_history(symbol, &charts)
+}
+
+#[cfg_attr(not(test), allow(dead_code))]
+#[allow(dead_code)]
+#[cfg(test)]
+mod tests {
+    use super::{parse_fundamentals_from_str, parse_history_from_str, parse_quote_from_str};
+
+    fn minimal_quote_raw() -> &'static str {
+        r#"[{"symbol":"BBCA","marketCap":1215200000000000}]"#
+    }
+
+    #[test]
+    fn parses_quote_fixture_json() {
+        let raw = std::fs::read_to_string("tests/fixtures/msn_quote_bbca.json")
+            .expect("quote fixture exists");
+        let quote = parse_quote_from_str("BBCA.JK", &raw).expect("quote parsed");
+        assert_eq!(quote.symbol, "BBCA.JK");
+        assert_eq!(quote.price, 9875);
+        assert_eq!(quote.change, Some(117));
+        assert_eq!(quote.volume, Some(12_300_000));
+        assert_eq!(quote.market_cap, Some(1_215_200_000_000_000));
+        assert_eq!(quote.avg_volume, Some(10_000_000));
+    }
+
+    #[test]
+    fn parses_fundamentals_fixture_json() {
+        let raw = std::fs::read_to_string("tests/fixtures/msn_keyratios_bbca.json")
+            .expect("fundamentals fixture exists");
+        let quote_raw = std::fs::read_to_string("tests/fixtures/msn_quote_bbca.json")
+            .expect("quote fixture exists");
+        let fundamentals =
+            parse_fundamentals_from_str(&raw, Some(&quote_raw)).expect("fundamentals parsed");
+        assert_eq!(fundamentals.trailing_pe, Some(25.4));
+        assert_eq!(fundamentals.price_to_book, Some(4.6));
+        assert_eq!(fundamentals.return_on_equity, Some(0.198));
+        assert_eq!(fundamentals.revenue_growth, Some(0.081));
+        assert_eq!(fundamentals.earnings_growth, Some(0.121));
+        assert_eq!(fundamentals.market_cap, Some(1_215_200_000_000_000));
+    }
+
+    #[test]
+    fn parses_history_fixture_json() {
+        let raw = std::fs::read_to_string("tests/fixtures/msn_chart_bbca_3m.json")
+            .expect("chart fixture exists");
+        let history = parse_history_from_str("BBCA.JK", &raw).expect("chart fixture parsed");
+
+        assert_eq!(history.len(), 3);
+        assert_eq!(history[0].date.to_string(), "2026-01-14");
+        assert_eq!(history[0].close, 8000);
+    }
+
+    #[test]
+    fn parses_fundamentals_with_infinity_string_as_missing_data() {
+        let raw = r#"[
+            {
+                "companyMetrics": [
+                    {
+                        "year": "2025",
+                        "fiscalPeriodType": "TTM",
+                        "priceToEarningsRatio": "Infinity",
+                        "priceToBookRatio": 4.6,
+                        "roe": 19.8,
+                        "profitMargin": 44.2,
+                        "debtToEquityRatio": 0.75,
+                        "currentRatio": 1.4
+                    }
+                ]
+            }
+        ]"#;
+
+        let fundamentals = parse_fundamentals_from_str(raw, Some(minimal_quote_raw()))
+            .expect("fundamentals parsed");
+
+        assert_eq!(fundamentals.trailing_pe, None);
+        assert_eq!(fundamentals.price_to_book, Some(4.6));
+        assert_eq!(fundamentals.return_on_equity, Some(0.198));
+    }
+
+    #[test]
+    fn parses_fundamentals_with_negative_infinity_string_as_missing_data() {
+        let raw = r#"[
+            {
+                "companyMetrics": [
+                    {
+                        "year": "2025",
+                        "fiscalPeriodType": "TTM",
+                        "priceToEarningsRatio": 12.5,
+                        "debtToEquityRatio": "-Infinity",
+                        "roe": 19.8,
+                        "profitMargin": 44.2,
+                        "currentRatio": 1.4
+                    }
+                ]
+            }
+        ]"#;
+
+        let fundamentals = parse_fundamentals_from_str(raw, Some(minimal_quote_raw()))
+            .expect("fundamentals parsed");
+
+        assert_eq!(fundamentals.trailing_pe, Some(12.5));
+        assert_eq!(fundamentals.debt_to_equity, None);
+        assert_eq!(fundamentals.return_on_equity, Some(0.198));
+    }
+
+    #[test]
+    fn parses_fundamentals_with_nan_string_as_missing_data() {
+        let raw = r#"[
+            {
+                "companyMetrics": [
+                    {
+                        "year": "2025",
+                        "fiscalPeriodType": "TTM",
+                        "revenueGrowthRate": "NaN",
+                        "earningsGrowthRate": 12.1,
+                        "roe": 19.8,
+                        "profitMargin": 44.2,
+                        "debtToEquityRatio": 0.75,
+                        "currentRatio": 1.4
+                    }
+                ]
+            }
+        ]"#;
+
+        let fundamentals = parse_fundamentals_from_str(raw, Some(minimal_quote_raw()))
+            .expect("fundamentals parsed");
+
+        assert_eq!(fundamentals.revenue_growth, None);
+        assert_eq!(fundamentals.earnings_growth, Some(0.121));
+        assert_eq!(fundamentals.return_on_equity, Some(0.198));
+    }
+}

crates/idx-core/src/api/msn/raw_types.rs

@@ -0,0 +1,393 @@
+use std::collections::HashMap;
+
+use serde::de::Error as _;
+use serde::{Deserialize, Deserializer, Serialize};
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct MsnQuote {
+    #[serde(default)]
+    pub(crate) symbol: Option<String>,
+    #[serde(default)]
+    pub(crate) short_name: Option<String>,
+    pub(crate) price: Option<f64>,
+    #[serde(default)]
+    pub(crate) price_change: Option<f64>,
+    #[serde(default)]
+    pub(crate) price_change_percent: Option<f64>,
+    #[serde(default)]
+    pub(crate) price_previous_close: Option<f64>,
+    #[serde(default, rename = "price52wHigh")]
+    pub(crate) price_52w_high: Option<f64>,
+    #[serde(default, rename = "price52wLow")]
+    pub(crate) price_52w_low: Option<f64>,
+    #[serde(default)]
+    pub(crate) accumulated_volume: Option<f64>,
+    #[serde(default)]
+    pub(crate) average_volume: Option<f64>,
+    #[serde(default)]
+    pub(crate) market_cap: Option<f64>,
+    #[serde(default)]
+    pub(crate) return_ytd: Option<f64>,
+    #[serde(default)]
+    pub(crate) time_last_traded: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct KeyRatios {
+    #[allow(dead_code)]
+    #[serde(default)]
+    pub(crate) industry_metrics: Vec<IndustryMetric>,
+    #[serde(default)]
+    pub(crate) company_metrics: Vec<IndustryMetric>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct IndustryMetric {
+    pub(crate) year: Option<String>,
+    pub(crate) fiscal_period_type: Option<String>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) revenue_growth_rate: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) earnings_growth_rate: Option<f64>,
+    #[serde(
+        default,
+        rename = "netIncomeYTDYTDGrowthRate",
+        deserialize_with = "de_opt_f64_lenient"
+    )]
+    pub(crate) net_income_ytd_ytd_growth_rate: Option<f64>,
+    #[serde(
+        default,
+        rename = "revenueYTDYTD",
+        deserialize_with = "de_opt_f64_lenient"
+    )]
+    pub(crate) revenue_ytd_ytd: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) net_margin: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) profit_margin: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) roe: Option<f64>,
+    #[serde(default, rename = "roaTTM", deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) roa_ttm: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) return_on_asset_current: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) debt_to_equity_ratio: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) current_ratio: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) price_to_earnings_ratio: Option<f64>,
+    #[serde(
+        default,
+        rename = "forwardPriceToEPS",
+        deserialize_with = "de_opt_f64_lenient"
+    )]
+    pub(crate) forward_price_to_eps: Option<f64>,
+    #[serde(default, deserialize_with = "de_opt_f64_lenient")]
+    pub(crate) price_to_book_ratio: Option<f64>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawEquity {
+    pub(super) id: Option<String>,
+    pub(super) symbol: Option<String>,
+    pub(super) short_name: Option<String>,
+    pub(super) long_name: Option<String>,
+    pub(super) display_name: Option<String>,
+    pub(super) description: Option<String>,
+    pub(super) sector: Option<String>,
+    pub(super) industry: Option<String>,
+    pub(super) website: Option<String>,
+    pub(super) full_time_employees: Option<i64>,
+    pub(super) address: Option<String>,
+    pub(super) city: Option<String>,
+    pub(super) country: Option<String>,
+    pub(super) phone: Option<String>,
+    pub(super) officers: Option<Vec<RawOfficer>>,
+    pub(super) company: Option<RawCompany>,
+    pub(super) localized_attributes: Option<HashMap<String, RawLocalizedAttribute>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawOfficer {
+    pub(super) name: Option<String>,
+    pub(super) title: Option<String>,
+    pub(super) age: Option<i32>,
+    pub(super) year_born: Option<i32>,
+    pub(super) total_pay: Option<i64>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawCompany {
+    pub(super) address: Option<RawCompanyAddress>,
+    pub(super) description: Option<String>,
+    pub(super) employees: Option<i64>,
+    pub(super) industry: Option<String>,
+    pub(super) sector: Option<String>,
+    pub(super) website: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawCompanyAddress {
+    pub(super) street: Option<String>,
+    pub(super) city: Option<String>,
+    pub(super) country: Option<String>,
+    pub(super) phone: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawLocalizedAttribute {
+    pub(super) display_name: Option<String>,
+    pub(super) description: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawFinancialStatement {
+    pub(super) underlying_instrument: Option<RawInstrumentInfo>,
+    pub(super) balance_sheets: Option<RawStatementSection>,
+    pub(super) cash_flow: Option<RawStatementSection>,
+    #[serde(rename = "incomeStatement")]
+    pub(super) income_statements: Option<RawStatementSection>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawInstrumentInfo {
+    pub(super) instrument_id: Option<String>,
+    pub(super) display_name: Option<String>,
+    pub(super) short_name: Option<String>,
+    pub(super) symbol: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+pub(super) struct RawStatementSection {
+    #[serde(flatten)]
+    pub(super) data: HashMap<String, serde_json::Value>,
+    pub(super) currency: Option<String>,
+    pub(super) source: Option<String>,
+    #[serde(rename = "sourceDate")]
+    pub(super) source_date: Option<String>,
+    #[serde(rename = "reportDate")]
+    pub(super) report_date: Option<String>,
+    #[serde(rename = "endDate")]
+    pub(super) end_date: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub(super) struct RawEarningsResponse {
+    pub(super) eps_last_year: Option<f64>,
+    pub(super) revenue_last_year: Option<f64>,
+    pub(super) forecast: Option<RawEarningsBucket>,
+    pub(super) history: Option<RawEarningsBucket>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct RawEarningsBucket {
+    pub(super) annual: Option<HashMap<String, RawEarningsData>>,
+    pub(super) quarterly: Option<HashMap<String, RawEarningsData>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub(super) struct RawEarningsData {
+    pub(super) eps_actual: Option<f64>,
+    pub(super) eps_surprise: Option<f64>,
+    pub(super) eps_surprise_percent: Option<f64>,
+    pub(super) eps_forecast: Option<f64>,
+    pub(super) revenue_actual: Option<f64>,
+    pub(super) revenue_surprise: Option<f64>,
+    pub(super) revenue_forecast: Option<f64>,
+    pub(super) earning_release_date: Option<String>,
+    pub(super) ciq_fiscal_period_type: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawSentiment {
+    pub(super) symbol: Option<String>,
+    pub(super) display_name: Option<String>,
+    pub(super) sentiment_statistics: Option<Vec<RawSentimentStat>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawSentimentStat {
+    pub(super) time_range_name: Option<String>,
+    pub(super) bullish: Option<i32>,
+    pub(super) bearish: Option<i32>,
+    pub(super) neutral: Option<i32>,
+}
+
+// Actual MSN insights API response: array of insight containers, each holding
+// individual insight items grouped by category (Valuation, Risk, etc.)
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawInsight {
+    pub(super) instrument_id: Option<String>,
+    pub(super) display_name: Option<String>,
+    pub(super) insights: Option<Vec<RawInsightItem>>,
+    pub(super) time_last_updated: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawInsightItem {
+    pub(super) insight_name: Option<String>,
+    pub(super) category: Option<String>,
+    pub(super) insight_statement: Option<String>,
+    pub(super) short_insight_statement: Option<String>,
+    pub(super) details: Option<RawInsightDetails>,
+    pub(super) time_last_updated: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawInsightDetails {
+    pub(super) evaluation_status: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct RawNewsFeed {
+    pub(super) value: Option<Vec<RawNewsItem>>,
+    #[serde(rename = "subCards")]
+    pub(super) sub_cards: Option<Vec<RawNewsItem>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawNewsItem {
+    pub(super) id: Option<String>,
+    pub(super) title: Option<String>,
+    pub(super) url: Option<String>,
+    #[serde(rename = "abstract")]
+    pub(super) description: Option<String>,
+    pub(super) provider: Option<RawNewsProvider>,
+    pub(super) published_date_time: Option<String>,
+    pub(super) read_time_min: Option<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct RawNewsProvider {
+    pub(super) name: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct ScreenerRequest {
+    pub(super) filter: Vec<ScreenerFilter>,
+    pub(super) order: ScreenerOrder,
+    pub(super) return_value_type: Vec<String>,
+    pub(super) screener_type: String,
+    pub(super) limit: usize,
+    pub(super) page_index: usize,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct ScreenerFilter {
+    pub(super) key: String,
+    pub(super) key_group: String,
+    pub(super) is_range: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub(super) struct ScreenerOrder {
+    pub(super) key: String,
+    pub(super) dir: String,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawScreenerResponse {
+    pub(super) count: Option<i32>,
+    pub(super) quote: Option<Vec<MsnQuote>>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawChartResponse {
+    #[serde(rename = "_p")]
+    pub(super) id: Option<String>,
+    pub(super) chart_type: Option<String>,
+    pub(super) symbol: Option<String>,
+    pub(super) series: Option<RawChartSeries>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawChartSeries {
+    #[serde(default)]
+    pub(super) time_stamps: Vec<String>,
+    #[serde(default)]
+    pub(super) prices: Vec<Option<f64>>,
+    #[serde(default)]
+    pub(super) open_prices: Vec<Option<f64>>,
+    #[serde(default)]
+    pub(super) prices_high: Vec<Option<f64>>,
+    #[serde(default)]
+    pub(super) prices_low: Vec<Option<f64>>,
+    #[serde(default)]
+    pub(super) volumes: Vec<Option<f64>>,
+    pub(super) start_time: Option<String>,
+    pub(super) end_time: Option<String>,
+}
+
+fn de_opt_f64_lenient<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum NumberLike {
+        F64(f64),
+        String(String),
+    }
+
+    let value = Option::<NumberLike>::deserialize(deserializer)?;
+    match value {
+        Some(NumberLike::F64(number)) if number.is_finite() => Ok(Some(number)),
+        Some(NumberLike::F64(_)) => Ok(None),
+        Some(NumberLike::String(raw)) => {
+            let trimmed = raw.trim();
+            if trimmed.is_empty()
+                || trimmed.eq_ignore_ascii_case("nan")
+                || trimmed.eq_ignore_ascii_case("infinity")
+                || trimmed.eq_ignore_ascii_case("-infinity")
+            {
+                Ok(None)
+            } else {
+                trimmed
+                    .parse::<f64>()
+                    .map_err(D::Error::custom)
+                    .map(|number| {
+                        if number.is_finite() {
+                            Some(number)
+                        } else {
+                            None
+                        }
+                    })
+            }
+        }
+        None => Ok(None),
+    }
+}

crates/idx-core/src/api/msn/symbol_ids.tsv

@@ -0,0 +1,896 @@
+AADI	cfatz2
+AALI	bn8zk2
+ABBA	bkf9ec
+ABDA	bkf9h7
+ABMM	bkf9k2
+ACES	bn8zyc
+ACRO	cc48gh
+ACST	bkf9pr
+ADCP	c59mf2
+ADES	bkf9sm
+ADHI	bn9127
+ADMF	bkf9yc
+ADMG	bn9152
+ADMR	c4pl52
+ADRO	bn917w
+AEGS	carobh
+AGAR	bsu9xm
+AGII	bkfa7w
+AGRO	bkfaar
+AGRS	bkfadm
+AHAP	bkfagh
+AIMS	bkfajc
+AISA	bkfam7
+AKKU	bkfctc
+AKPI	bkfcw7
+AKRA	bkfcz2
+AKSI	bkfd2w
+ALDO	bkfd5r
+ALII	ccanzr
+ALKA	bkfd8m
+ALMI	bkfdbh
+ALTO	bkfdec
+AMAG	bkfchw
+AMAN	btysar
+AMAR	btf6a2
+AMFG	bkfckr
+AMIN	bkfcnm
+AMMN	ca993m
+AMMS	c6yaw7
+AMOR	btfbw7
+AMRT	bkfcqh
+ANDI	bgrwf2
+ANJT	bkfem7
+ANTM	bn8zmw
+APEX	bkferw
+APIC	bkfeur
+APII	bkfexm
+APLI	bkff1h
+APLN	bkff4c
+ARCI	c2il1h
+AREA	ccsom7
+ARGO	bkff77
+ARII	bkffa2
+ARKA	bqtwtc
+ARKO	c6qaqh
+ARNA	bkfffr
+ARTA	bkffim
+ARTO	bkffoc
+ASBI	bkffzr
+ASDM	bkfg3m
+ASGR	bkfg6h
+ASHA	c6a3yc
+ASII	bn91gh
+ASJT	bkfgc7
+ASLC	c4xl52
+ASLI	cc41ww
+ASMI	bkfgf2
+ASPI	btr8pr
+ASPR	chbyjc
+ASRI	bkfghw
+ASRM	bkfgkr
+ASSA	bkfgnm
+ATAP	bwzup2
+ATIC	bkffr7
+ATLA	ccwjvh
+AUTO	bkffu2
+AVIA	c4bepr
+AWAN	c9f9yc
+AXIO	c6v4pr
+AYAM	cbkfkr
+AYLS	btox8m
+BABP	bkfgqh
+BABY	carnqh
+BACA	bkfgtc
+BAIK	ccbzar
+BAJA	bkfgw7
+BALI	bkfgz2
+BANK	bxjrc7
+BAPA	bkfh2w
+BAPI	breeur
+BATA	bkflyc
+BATR	cddzvh
+BAUT	c4xpm7
+BAYU	bkfm27
+BBCA	bn91jc
+BBHI	bkfm7w
+BBKP	bkfmar
+BBLD	bkfmdm
+BBMD	bkfmgh
+BBNI	bn91m7
+BBRI	bn91p2
+BBRM	bkfmrw
+BBSI	bvpgvh
+BBSS	bu9cqh
+BBTN	bkfmur
+BBYB	bkfmxm
+BCAP	bkfn1h
+BCIC	bgt4rw
+BCIP	bkfn4c
+BDKR	c8zmyc
+BDMN	bn91rw
+BEBS	bzv7ar
+BEEF	bokavh
+BEER	c8if77
+BEKS	bkfna2
+BELI	c7svnm
+BELL	bkfncw
+BESS	btyakr
+BEST	bkfh5r
+BFIN	bkfh8m
+BGTG	bkfhbh
+BHAT	bua6k2
+BHIT	bkfhec
+BIKE	c5iucw
+BIMA	bkfkz2
+BINA	bn92u2
+BINO	c45tp2
+BIPI	bn92ww
+BIPP	bkfl8m
+BIRD	bkflbh
+BISI	bn92zr
+BJBR	bkflh7
+BJTM	bn936h
+BKDP	bkflmw
+BKSL	bkflpr
+BKSW	bkflsm
+BLES	cdlvh7
+BLOG	chc7m7
+BLTA	bgt5u2
+BLTZ	bkflvh
+BLUE	bqrgar
+BMAS	bkfoqh
+BMBL	c8isqh
+BMHS	c2md4c
+BMRI	bn939c
+BMSR	bkfow7
+BMTR	bkfoz2
+BNBA	bkfp2w
+BNBR	bn93c7
+BNGA	bkfp8m
+BNII	bn93f2
+BNLI	bn93hw
+BOAT	cf4yu2
+BOBA	c3wioc
+BOGA	bkfph7
+BOLA	bqe3p2
+BOLT	bkfpk2
+BPFI	bkfppr
+BPII	bkfpsm
+BPTR	bgth1h
+BRAM	bkfpvh
+BREN	cb1ra2
+BRIS	bgtha2
+BRMS	bn924c
+BRNA	bkfq27
+BRPT	bn9277
+BRRC	cflfa2
+BSBK	c7svhw
+BSDE	bkfq7w
+BSIM	bn92a2
+BSML	c4is3m
+BSSR	bkfqdm
+BSWD	bkfqgh
+BTEK	bkfqjc
+BTON	bkfqp2
+BTPN	bkfqrw
+BTPS	bgtwjc
+BUAH	c71dyc
+BUDI	bkfqur
+BUKA	c2wgkr
+BUKK	bkfqxm
+BULL	bkfnu2
+BUMI	bn92fr
+BUVA	bkfnzr
+BVIC	bkfo3m
+BWPT	bn92im
+BYAN	bn92lh
+CAKK	bne4c7
+CAMP	bkfoc7
+CANI	bkfof2
+CARE	btysdm
+CARS	bkfohw
+CASA	bkfokr
+CASH	bufc7w
+CASS	bkfonm
+CBDK	cflejc
+CBPE	c8ipmw
+CBRE	c8ifww
+CBUT	c7sxgh
+CCSI	bqh6ar
+CDIA	chdaw7
+CEKA	bkfkqh
+CENT	bkfktc
+CFIN	bkfkw7
+CGAS	cc45zr
+CHEK	chddzr
+CHEM	c6qahw
+CHIP	c8qlmw
+CINT	bkfnfr
+CITA	bkfnim
+CITY	bjs6w7
+CLAY	bona52
+CLEO	bkfnoc
+CLPI	bkfnr7
+CMNP	bn93kr
+CMNT	c3bxcw
+CMPP	bkgku2
+CMRY	c4b81h
+CNKO	bkgkzr
+CNMA	cagkkr
+COAL	c78lp2
+COCO	bpfy1h
+COIN	chc7p2
+CPIN	bn93nm
+CPRO	bkgl9c
+CRAB	c71ep2
+CRSN	ca9dnm
+CSAP	bn93z2
+CSIS	bkglf2
+CSMI	bua4a2
+CSRA	btf6cw
+CTBN	bkglhw
+CTRA	bn942w
+CTTH	bkglnm
+CUAN	c8ztf2
+CYBR	caj9jc
+DAAZ	cf3dr7
+DADA	btov1h
+DART	bkglqh
+DATA	cd3e27
+DAYA	bkgltc
+DCII	bxbr3m
+DEFI	bkglw7
+DEPO	c461k2
+DEWA	bn93qh
+DEWI	c6t4oc
+DFAM	bkgm2w
+DGIK	bkgm5r
+DGNS	bxbs2w
+DGWG	cfl46h
+DIGI	bguqr7
+DILD	bn93tc
+DIVA	bny8f2
+DKFT	bkgmbh
+DKHH	cgo8rw
+DLTA	bkgn52
+DMAS	bkgn7w
+DMMX	bsh6z2
+DMND	bti2qh
+DNAR	bkgnar
+DNET	bkgndm
+DOID	bkgngh
+DOOH	c9pg52
+DOSS	cecd8m
+DPNS	bkgnjc
+DPUM	bkgnm7
+DRMA	c4is9c
+DSFI	bkgnp2
+DSNG	bkgnrw
+DSSA	bn94ec
+DUTI	bn94h7
+DVLA	bkgmsm
+DWGL	bkgmvh
+DYAN	bkgmyc
+EAST	bqrjmw
+ECII	bkgn27
+EDGE	bxmmkr
+EKAD	bkgmec
+ELIT	c8ifcw
+ELPI	c71dh7
+ELSA	bkgmh7
+ELTY	bn94k2
+EMAS	ci4x5r
+EMDE	bkgo77
+EMTK	bkgocw
+ENAK	c53nww
+ENRG	bkgofr
+ENZO	bvqna2
+EPAC	buzekr
+EPMT	bkgoim
+ERAA	bkgolh
+ERAL	cakb4c
+ERTX	bkgooc
+ESIP	bsq1dm
+ESSA	bkgnxm
+ESTA	btxltc
+ESTI	bkgo1h
+EURO	c6zylh
+EXCL	bn94pr
+FAPA	bx7mww
+FAST	bkgor7
+FASW	bkgou2
+FILM	bgva7w
+FIMP	c1paqh
+FIRE	bkgozr
+FISH	bkgp3m
+FITT	bqcw2w
+FLMC	c2p22w
+FMII	bkgp9c
+FOLK	caj9ar
+FOOD	bohgur
+FORE	cghp7w
+FORU	bkgpc7
+FPNI	bkgphw
+FUJI	bqrhww
+FUTR	c8xc2w
+FWCT	c8no4c
+GDST	bkgpnm
+GDYR	bkgpqh
+GEMA	bkgptc
+GEMS	bkgpw7
+GGRM	bn94vh
+GGRP	brivww
+GHON	bkgq2w
+GIAA	bkgq5r
+GJTL	bn9527
+GLOB	bgveur
+GLVA	bt94fr
+GMFI	bkgqbh
+GMTD	bkgqk2
+GOLD	bkgqmw
+GOLF	cdml52
+GOOD	bkgqsm
+GOTO	c5tv8m
+GPRA	bkgqvh
+GPSO	c39qp2
+GRIA	cakam7
+GRPH	cc65vh
+GRPM	ca9bar
+GSMF	bkgqec
+GTBO	bkgqh7
+GTRA	c9a7c7
+GTSI	c3atkr
+GULA	c6ybbh
+GUNA	cdm6oc
+GWSA	bkgqyc
+GZCO	bkgr27
+HADE	bkgr52
+HAIS	c3839c
+HAJJ	c9c9z2
+HALO	c8snbh
+HATM	c6vxxm
+HBAT	caj5ur
+HDFA	bkgr7w
+HDIT	bqsr9c
+HEAL	bgvigh
+HELI	bkgrdm
+HERO	bkgrgh
+HEXA	bn95ar
+HGII	cfl3r7
+HILL	c8xfhw
+HITS	bkgrm7
+HMSP	bn95jc
+HOKI	bkgrur
+HOMI	bvpl7w
+HOPE	c24y52
+HRME	bpplhw
+HRTA	bkgs4c
+HRUM	bn957w
+HUMI	caj9p2
+HYGN	ccbzjc
+IATA	bkgsa2
+IBFN	bkgscw
+IBOS	c5z1vh
+IBST	bkgsfr
+ICBP	bkgsim
+ICON	bkgslh
+IDEA	c3at9c
+IDPR	bkgsoc
+IFII	bt26w7
+IFSH	bsua4c
+IGAR	bkgsr7
+IKAI	bkgsww
+IKAN	btov4c
+IKBI	bkgszr
+IKPM	cbetnm
+IMAS	bkguk2
+IMJS	bkgumw
+IMPC	bkgupr
+INAI	bkguvh
+INCF	bkguyc
+INCI	bkgv27
+INCO	bn96cw
+INDF	bn96fr
+INDO	btf6ww
+INDR	bkgvar
+INDS	bkgvdm
+INDX	bkgvgh
+INDY	bkgvjc
+INET	caehu2
+INKP	bn96im
+INOV	bqtw6h
+INPC	bkgttc
+INPP	bkgtw7
+INPS	bkgtz2
+INRU	bkgu2w
+INTA	bkgu5r
+INTD	bkgu8m
+INTP	bn95m7
+IOTF	cb1mar
+IPAC	c2ip4c
+IPCC	bgvlmw
+IPCM	bkguec
+IPOL	bkguh7
+IPTV	bqrdim
+IRRA	bs6n9c
+IRSX	c8ptdm
+ISAP	c87m5r
+ISAT	bn95p2
+ISEA	cdmkyc
+ISSP	bn95rw
+ITIC	bqptyc
+ITMA	bkgt9c
+ITMG	bn95ur
+JARR	c6yb2w
+JAST	bpztur
+JATI	c9pikr
+JAWA	bkgtf2
+JAYA	bp3fkr
+JECC	bkgthw
+JGLE	bkgtkr
+JIHD	bkgtnm
+JKON	bn95xm
+JMAS	bkgwcw
+JPFA	bkgwfr
+JRPT	bkgwim
+JSMR	bn964c
+JSPT	bkgwr7
+JTPE	bkgwu2
+KAEF	bkgvp2
+KAQI	cg3ah7
+KARW	bkgvrw
+KBAG	bu8obh
+KBLI	bkgvur
+KBLM	bkgvxm
+KBLV	bkgw1h
+KDSI	bkgwww
+KDTN	c7sxar
+KEEN	brdma2
+KEJU	bss8im
+KETR	c7x3cw
+KIAS	bgw8lh
+KICI	bkgwzr
+KIJA	bkgx3m
+KING	c8v3jc
+KINO	bkgx6h
+KIOS	bkgx9c
+KJEN	bqoa1h
+KKES	c71dsm
+KKGI	bkgxqh
+KLAS	c9zg9c
+KLBF	bn96u2
+KLIN	c71ear
+KMDS	bvpjz2
+KMTR	bkgxw7
+KOBX	bkgxz2
+KOCI	cazma2
+KOIN	bkgy2w
+KOKA	cb2m5r
+KONI	bkgy5r
+KOPI	bkgy8m
+KOTA	bqspm7
+KPIG	bkgxf2
+KRAS	bn96zr
+KREN	bkgxnm
+KRYA	c6vopr
+KSIX	cfl4f2
+KUAS	c3tgqh
+LABA	c2ekur
+LABS	cdml7w
+LAJU	c8ni2w
+LAND	bgwfxm
+LAPD	bkgybh
+LCKM	bkgyh7
+LEAD	bkgyk2
+LFLO	c1g5f2
+LIFE	bqsrz2
+LINK	bkgymw
+LION	bkgypr
+LIVE	ccbz52
+LMAX	caj9gh
+LMPI	bkgyyc
+LMSH	bkgz27
+LOPI	cb2a2w
+LPCK	bkgz52
+LPGI	bkgz7w
+LPIN	bkgzar
+LPKR	bn99ar
+LPLI	bn99dm
+LPPF	bkgzjc
+LPPS	bn99gh
+LRNA	bkgzp2
+LSIP	bn99jc
+LTLS	bkgzur
+LUCK	bny8z2
+LUCY	c1zlh7
+MAHA	caem3m
+MAIN	bkh177
+MANG	cc463m
+MAPA	bgwzm7
+MAPB	bkh1cw
+MAPI	bn98pr
+MARI	bkh1im
+MARK	bkh1lh
+MASB	c2jw8m
+MAXI	c9zd5r
+MAYA	bkh1r7
+MBAP	bkh1u2
+MBMA	c9fe52
+MBSS	bkh1ww
+MBTO	bkh1zr
+MCAS	bkh23m
+MCOL	c3apnm
+MCOR	bkh26h
+MDIA	bkh2c7
+MDIY	cff1lh
+MDKA	bkh2f2
+MDKI	bkh2hw
+MDLA	cgbphw
+MDLN	bkh2kr
+MDRN	bkh2nm
+MEDC	bn9a77
+MEDS	c71idm
+MEGA	bkh2tc
+MEJA	ccbqh7
+MENN	c9fbu2
+MERI	che6cw
+MERK	bkh2w7
+MFMI	bkh35r
+MGLV	c2cba2
+MGNA	bkh38m
+MGRO	bgxdcw
+MHKI	ccwk27
+MICE	bn9afr
+MIDI	bn9aim
+MIKA	bkh3h7
+MINA	bkh427
+MINE	cg3epr
+MIRA	bkh452
+MITI	bkh47w
+MKAP	ccbrar
+MKPI	bkh4dm
+MKTR	c7sz6h
+MLBI	bkh4gh
+MLIA	bkh4jc
+MLPL	bn9alh
+MLPT	bkh4p2
+MMIX	c87lz2
+MMLP	bkh4rw
+MNCN	bkh4ur
+MOLI	b9fksm
+MORA	c6zya2
+MPIX	ccbqmw
+MPMX	bkh3mw
+MPOW	bkh3pr
+MPPA	bn9azr
+MPRO	bkh3vh
+MPXL	c9ql7w
+MRAT	bkh3yc
+MREI	bkhcur
+MSIE	cakqgh
+MSIN	bgy7nm
+MSJA	cc466h
+MSKY	bkhcxm
+MSTI	cbe9qh
+MTDL	bkhd1h
+MTEL	c45acw
+MTFN	bgy82w
+MTLA	bkhd4c
+MTMH	c5w4lh
+MTPS	bpmq9c
+MTSM	bkhda2
+MTWI	bkhdfr
+MUTU	cajgyc
+MYOH	bkhcgh
+MYOR	bn9bkr
+MYTX	bkhcp2
+NAIK	cf6abh
+NANO	c5es5r
+NASA	bkhc52
+NASI	c4earw
+NATO	bor3r7
+NAYZ	c8pvw7
+NCKL	c9dmnm
+NELY	bkhcar
+NEST	cecdh7
+NETV	c4zpnm
+NFCX	bh2cm7
+NICE	cc46f2
+NICK	bkhdoc
+NICL	c2og3m
+NIKL	bkhdr7
+NINE	c87ih7
+NIRO	bkhdww
+NISP	bkhdzr
+NOBU	bkhe3m
+NPGF	c1mpp2
+NRCA	bkhe9c
+NSSS	c92ssm
+NTBK	c53nim
+NZIA	brkv8m
+OASA	bkhdim
+OBAT	cflf77
+OBMD	c4dnkr
+OILS	c3a84c
+OKAS	bkhdlh
+OLIV	c64i27
+OMED	c7t2jc
+OMRE	bkhekr
+OPMS	brkez2
+PACK	c8sn2w
+PADA	c87qyc
+PADI	bkheqh
+PALM	bkhetc
+PAMG	bqrcxm
+PANI	bh3952
+PANR	bkhez2
+PANS	bkhf2w
+PART	cdlta2
+PBID	bkhf5r
+PBRX	bkhf8m
+PBSA	bkhfbh
+PCAR	bkhfec
+PDES	bkhfh7
+PDPP	c7wzkr
+PEGE	bkhfk2
+PEHA	boeyr7
+PEVE	c8lqu2
+PGAS	bn9ch7
+PGEO	c8wmc7
+PGJO	btf6im
+PGLI	bkhfpr
+PGUN	bv2tpr
+PICO	bkhfvh
+PIPA	c9cy5r
+PJAA	bkhfyc
+PKPK	bkhh1h
+PLAN	bvsmnm
+PLIN	bkhh77
+PMJS	bt81mw
+PMMP	bx3rtc
+PMUI	che6fr
+PNBN	bn9d27
+PNBS	bn9d52
+PNGO	bvilbh
+PNIN	bkhhfr
+PNLF	bn9d7w
+PNSE	bkhhlh
+POLA	bnw452
+POLI	bokeh7
+POLU	bqiq5r
+POLY	bkhg27
+PORT	bkhg7w
+POWR	bn9dar
+PPGL	bv7ka2
+PPRE	bkhgdm
+PPRI	caj5xm
+PPRO	bkhggh
+PRAY	c7svf2
+PRDA	bkhgm7
+PRIM	bh3bnm
+PSAB	bkhgp2
+PSDN	bkhgrw
+PSGO	bssb7w
+PSKT	bkhgur
+PSSI	bkhgxm
+PTBA	bn9i4c
+PTDU	bwzbim
+PTIS	bkhif2
+PTMP	c8zh3m
+PTMR	cese7w
+PTPP	bkhihw
+PTPS	cb26pr
+PTPW	btowc7
+PTRO	bkhinm
+PTSN	bkhiqh
+PTSP	bkhitc
+PUDP	bkhiw7
+PURA	btjqcw
+PURI	bvmvlh
+PWON	bkhiz2
+PYFA	bkhj2w
+PZZA	bh3dar
+RAAM	c9pg7w
+RAFI	c6zy1h
+RAJA	bkhhu2
+RALS	bn9iim
+RANC	bkhhzr
+RATU	cfl3oc
+RBMS	bkhi3m
+RCCC	c6y4ur
+RDTX	bkhi6h
+REAL	bsxdzr
+RELF	ca43u2
+RELI	bkhi9c
+RGAS	cbe25r
+RICY	bkhj5r
+RIGS	bkhj8m
+RISE	bh3par
+RMKE	c4bf52
+RMKO	cafyoc
+ROCK	bvpnqh
+RODA	bkhkur
+RONY	bua477
+ROTI	bkhkxm
+RSCH	caoza2
+RSGK	c3atf2
+RUIS	bkhjh7
+RUNS	c3athw
+SAFE	bh4khw
+SAGE	c8ztkr
+SAME	bkhl1h
+SAMF	bu77h7
+SAPX	bkhl4c
+SATU	bnmpyc
+SBMA	c3apw7
+SCCO	bkhl77
+SCMA	bkhla2
+SCNP	bvpljc
+SDMU	bkhlcw
+SDPC	bkhlfr
+SDRA	bkhlim
+SEMA	c4s94c
+SFAN	bqigoc
+SGER	bvdqa2
+SGRO	bn9j9c
+SHID	bkhlww
+SHIP	bkhlzr
+SICO	c5tatc
+SIDO	bkhm6h
+SILO	bn9jnm
+SIMP	bkhmf2
+SINI	bsn27w
+SIPD	bkhpzr
+SKBM	bkhq3m
+SKLT	bkhq6h
+SKRN	bkhqc7
+SLIS	bs6kh7
+SMAR	bkhrmw
+SMBR	bn9lar
+SMCB	bn9ldm
+SMDM	bkhryc
+SMDR	bkhs27
+SMGA	cc93tc
+SMGR	bn9lgh
+SMIL	c9r7oc
+SMKL	bqrfh7
+SMKM	c5gqk2
+SMLE	cc45oc
+SMMA	bkhs7w
+SMMT	bkhsar
+SMRA	bn9ljc
+SMSM	bkhsjc
+SNLK	c1c3ur
+SOCI	bkhmkr
+SOFA	bv1prw
+SOHO	bvpia2
+SOLA	cd3j77
+SONA	bkhmqh
+SOSS	borblh
+SOTS	bo5fk2
+SOUL	c8hmu2
+SPMA	bkhqhw
+SPRE	cdllww
+SPTO	bh4tpr
+SQMI	bkhqkr
+SRAJ	bkhqnm
+SRSN	bkhqw7
+SRTG	bkhqz2
+SSIA	bkhr2w
+SSMS	bkhr5r
+SSTM	bkhr8m
+STAA	c5grjc
+STAR	bkhrbh
+STRK	cb1rcw
+STTP	bkhrec
+SULI	bn9l52
+SUNI	c8irzr
+SUPR	bkhsp2
+SURE	bkhsrw
+SURI	cbriz2
+SWAT	bh4xyc
+SWID	c6q9ww
+TALF	bkhsxm
+TAMA	btnwec
+TAMU	bkht1h
+TAPG	c1pha2
+TARA	bkht4c
+TAXI	bkhta2
+TAYS	c4bfdm
+TBIG	bkhtcw
+TBLA	bn9m77
+TBMS	bkhtim
+TCID	bkhtlh
+TCPI	bh55nm
+TEBE	bsqufr
+TELE	bkhtr7
+TFAS	brgc52
+TFCO	bkhtzr
+TGKA	bkhu6h
+TGRA	bkhu9c
+TGUK	ca99f2
+TIFA	bkhuc7
+TINS	bn9o2w
+TIRA	bkhunm
+TIRT	bkhuqh
+TKIM	bn9o5r
+TLDN	c5tiqh
+TLKM	bn9o8m
+TMAS	bn9oec
+TMPO	bkhv8m
+TNCA	bh5cim
+TOBA	bkhvk2
+TOOL	c71edm
+TOSK	ccbqk2
+TOTL	bn9ok2
+TOTO	bkhvsm
+TOWR	bn9omw
+TPIA	bkhvyc
+TPMA	bkhw27
+TRGU	c6qatc
+TRIM	bki2lh
+TRIN	btfcbh
+TRIS	bki2oc
+TRJA	bviktc
+TRON	c8zthw
+TRST	bki2u2
+TRUE	c2cfa2
+TRUK	bh7r6h
+TRUS	bki2zr
+TSPC	bki33m
+TUGU	bh72cw
+TYRE	c9pfpr
+UANG	bv1qlh
+UCID	bt7nnm
+UDNG	cbazxm
+UFOE	bxjur7
+ULTJ	bki36h
+UNIC	bki39c
+UNIQ	bzv6mw
+UNSP	bn9pjc
+UNTD	ccanww
+UNTR	bn9pm7
+UNVR	bn9pp2
+URBN	bo5fsm
+UVCR	c2ruww
+VAST	c8sn8m
+VERN	cesblh
+VICI	bx3pp2
+VICO	bki3nm
+VINS	bki3qh
+VISI	cchqzr
+VIVA	bki45r
+VKTR	ca2e9c
+VOKS	bki4bh
+VRNA	bki4k2
+VTNY	c89txm
+WAPO	bki4mw
+WEGE	bki4pr
+WEHA	bki4sm
+WGSH	c4bevh
+WICO	bki76h
+WIDI	ca9dkr
+WIFI	bx86dm
+WIIM	bki79c
+WIKA	bn9q77
+WINE	c8isf2
+WINR	c5yu77
+WINS	bn9qa2
+WIRG	c5o9z2
+WMUU	bxjkec
+WOMF	bki7hw
+WOOD	bki7kr
+WOWS	bsnwf2
+WSBP	bki7z2
+WTON	bn9r9c
+YELO	bnehec
+YOII	cfl49c
+YPAS	bki8bh
+YULE	bki7nm
+YUPI	cgaarw
+ZATA	c7x3im
+ZBRA	bhacdm
+ZINC	bki7qh
+ZONE	bo5fyc
+ZYRX	c1c1kr

crates/idx-core/src/api/msn/symbols.rs

@@ -0,0 +1,56 @@
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+const SYMBOL_IDS_RAW: &str = include_str!("symbol_ids.tsv");
+
+static SYMBOL_IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
+
+fn symbol_ids() -> &'static HashMap<&'static str, &'static str> {
+    SYMBOL_IDS.get_or_init(|| {
+        SYMBOL_IDS_RAW
+            .lines()
+            .filter_map(|line| line.split_once('\t'))
+            .collect()
+    })
+}
+
+pub(crate) fn ticker_from_symbol(symbol: &str) -> Option<String> {
+    let trimmed = symbol.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    Some(
+        trimmed
+            .split('.')
+            .next()
+            .unwrap_or(trimmed)
+            .trim()
+            .to_uppercase(),
+    )
+}
+
+pub(crate) fn resolve_msn_id(symbol: &str) -> Option<&'static str> {
+    let ticker = ticker_from_symbol(symbol)?;
+    symbol_ids().get(ticker.as_str()).copied()
+}
+
+pub(crate) fn normalized_symbol(requested: &str, fallback_ticker: &str) -> String {
+    let trimmed = requested.trim().to_uppercase();
+    if trimmed.contains('.') || fallback_ticker.is_empty() {
+        trimmed
+    } else {
+        format!("{}.JK", fallback_ticker.trim().to_uppercase())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::resolve_msn_id;
+
+    #[test]
+    fn resolves_symbol_variants() {
+        assert_eq!(resolve_msn_id("BBCA"), Some("bn91jc"));
+        assert_eq!(resolve_msn_id("bbca.jk"), Some("bn91jc"));
+        assert_eq!(resolve_msn_id("INVALID"), None);
+    }
+}