@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/adapters/index.umd.js

@@ -0,0 +1,2535 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@vninvestcharts/engine-core'), require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@vninvestcharts/engine-core', 'react'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VNInvestChartsAdapters = {}, global.engineCore, global.react));
+})(this, (function (exports, engineCore, react) { 'use strict';
+
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/lib/adapters/rollAlgorithms.ts
+  var rollAlgorithms_exports = {};
+  __export(rollAlgorithms_exports, {
+    computeRollAdjustment: () => computeRollAdjustment,
+    computeSingleRollAdjustment: () => computeSingleRollAdjustment,
+    generateTestBarsWithRollGap: () => generateTestBarsWithRollGap,
+    generateTestContractChain: () => generateTestContractChain,
+    verifyNoPriceGaps: () => verifyNoPriceGaps
+  });
+  function computeRollAdjustment(input) {
+    const { contracts, contractBars, config, from, to } = input;
+    const { rollMethod, adjustVolumes } = config;
+    const allBars = [];
+    const rollPoints = [];
+    const warnings = [];
+    let cumulativeAdjustment = 0;
+    let currentRatioFactor = 1;
+    let currentPriceOffset = 0;
+    for (let i = 0; i < contracts.length; i++) {
+      const contract = contracts[i];
+      const bars = contractBars.get(contract.symbol) ?? [];
+      const contractStart = Math.max(contract.firstTradeDate, from);
+      const contractEnd = Math.min(contract.lastTradeDate, to);
+      let relevantBars = bars.filter(
+        (b) => b.timestamp >= contractStart && b.timestamp <= contractEnd
+      );
+      if (relevantBars.length === 0) {
+        warnings.push(`No data for contract ${contract.symbol} in range [${new Date(contractStart).toISOString()}, ${new Date(contractEnd).toISOString()}]`);
+        continue;
+      }
+      if (i > 0) {
+        relevantBars = applyCumulativeAdjustment(relevantBars, rollMethod, currentRatioFactor, currentPriceOffset, adjustVolumes);
+      }
+      allBars.push(...relevantBars);
+      if (i < contracts.length - 1) {
+        const nextContract = contracts[i + 1];
+        const nextBars = contractBars.get(nextContract.symbol) ?? [];
+        const rollDate = contract.lastTradeDate;
+        const fromBar = findBarAtOrBefore(relevantBars, rollDate);
+        const toBar = findBarAtOrAfter(nextBars, rollDate);
+        if (fromBar && toBar) {
+          const fromPrice = fromBar.close;
+          const toPrice = toBar.close;
+          const fromBarRaw = findBarAtOrBefore(bars, rollDate);
+          const rawFromPrice = fromBarRaw ? fromBarRaw.close : fromPrice;
+          const rawToPrice = toPrice;
+          let adjustmentFactor = 1;
+          let priceOffset = 0;
+          if (rollMethod === "ratio") {
+            adjustmentFactor = rawFromPrice / rawToPrice;
+            currentRatioFactor *= adjustmentFactor;
+          } else if (rollMethod === "panama") {
+            priceOffset = rawFromPrice - rawToPrice;
+            currentPriceOffset += priceOffset;
+            cumulativeAdjustment += priceOffset;
+          } else if (rollMethod === "backward-ratio") {
+            adjustmentFactor = rawToPrice / rawFromPrice;
+            currentRatioFactor *= adjustmentFactor;
+          }
+          const adjustedFromPrice = fromPrice;
+          let adjustedToPrice = toPrice;
+          if (rollMethod === "ratio") {
+            adjustedToPrice = toPrice * currentRatioFactor;
+          } else if (rollMethod === "panama") {
+            adjustedToPrice = toPrice + currentPriceOffset;
+          } else if (rollMethod === "backward-ratio") {
+            adjustedToPrice = toPrice / currentRatioFactor;
+          }
+          rollPoints.push({
+            timestamp: rollDate,
+            fromContract: contract.symbol,
+            toContract: nextContract.symbol,
+            fromPrice: adjustedFromPrice,
+            toPrice: adjustedToPrice,
+            adjustmentFactor: rollMethod === "panama" ? priceOffset : adjustmentFactor,
+            cumulativeAdjustment,
+            method: rollMethod
+          });
+        } else {
+          warnings.push(`Could not determine roll prices at ${new Date(rollDate).toISOString()} for ${contract.symbol} -> ${nextContract.symbol}`);
+        }
+      }
+    }
+    allBars.sort((a, b) => a.timestamp - b.timestamp);
+    const dedupedBars = deduplicateBars(allBars);
+    return {
+      bars: dedupedBars,
+      rollPoints,
+      totalCumulativeAdjustment: cumulativeAdjustment,
+      warnings
+    };
+  }
+  function applyCumulativeAdjustment(bars, method, ratioFactor, priceOffset, adjustVolumes) {
+    return bars.map((bar) => {
+      let { open, high, low, close, volume } = bar;
+      if (method === "ratio") {
+        open *= ratioFactor;
+        high *= ratioFactor;
+        low *= ratioFactor;
+        close *= ratioFactor;
+        if (adjustVolumes) {
+          volume = Math.round(volume / ratioFactor);
+        }
+      } else if (method === "panama") {
+        open += priceOffset;
+        high += priceOffset;
+        low += priceOffset;
+        close += priceOffset;
+      } else if (method === "backward-ratio") {
+        open /= ratioFactor;
+        high /= ratioFactor;
+        low /= ratioFactor;
+        close /= ratioFactor;
+        if (adjustVolumes) {
+          volume = Math.round(volume * ratioFactor);
+        }
+      }
+      return { ...bar, open, high, low, close, volume };
+    });
+  }
+  function findBarAtOrBefore(bars, timestamp) {
+    let result = null;
+    for (const bar of bars) {
+      if (bar.timestamp <= timestamp) {
+        result = bar;
+      } else {
+        break;
+      }
+    }
+    return result;
+  }
+  function findBarAtOrAfter(bars, timestamp) {
+    for (const bar of bars) {
+      if (bar.timestamp >= timestamp) {
+        return bar;
+      }
+    }
+    return null;
+  }
+  function deduplicateBars(bars) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const bar of bars) {
+      const existing = seen.get(bar.timestamp);
+      if (!existing || bar.volume > existing.volume) {
+        seen.set(bar.timestamp, bar);
+      }
+    }
+    return Array.from(seen.values()).sort((a, b) => a.timestamp - b.timestamp);
+  }
+  function computeSingleRollAdjustment(fromPrice, toPrice, method) {
+    if (method === "ratio" && toPrice === 0) {
+      throw new Error("toPrice cannot be zero for ratio roll adjustment");
+    }
+    if (method === "backward-ratio" && fromPrice === 0) {
+      throw new Error("fromPrice cannot be zero for backward-ratio roll adjustment");
+    }
+    switch (method) {
+      case "ratio":
+        return { factor: fromPrice / toPrice, offset: 0 };
+      case "panama":
+        return { factor: 1, offset: fromPrice - toPrice };
+      case "backward-ratio":
+        return { factor: toPrice / fromPrice, offset: 0 };
+      default:
+        throw new Error(`Unknown roll method: ${method}`);
+    }
+  }
+  function verifyNoPriceGaps(rollPoints, thresholdPercent = 0.1) {
+    const gaps = rollPoints.map((rp) => {
+      const gapPercent = Math.abs((rp.fromPrice - rp.toPrice) / rp.fromPrice) * 100;
+      return { rollPoint: rp, gapPercent };
+    });
+    const maxGap = Math.max(...gaps.map((g) => g.gapPercent), 0);
+    return {
+      passed: maxGap <= thresholdPercent,
+      gaps
+    };
+  }
+  function generateTestContractChain(rootSymbol, count, startDate, intervalDays = 90) {
+    const contracts = [];
+    const monthCodes = ["F", "G", "H", "J", "K", "M", "N", "Q", "U", "V", "X", "Z"];
+    for (let i = 0; i < count; i++) {
+      const firstTrade = startDate + i * intervalDays * 24 * 60 * 60 * 1e3;
+      const expiry = firstTrade + intervalDays * 24 * 60 * 60 * 1e3;
+      const lastTrade = expiry - 3 * 24 * 60 * 60 * 1e3;
+      const monthCode = monthCodes[i % 12];
+      const year = Math.floor(startDate / (365 * 24 * 60 * 60 * 1e3) + i / 4) % 100;
+      contracts.push({
+        symbol: `${rootSymbol}${year.toString().padStart(2, "0")}${monthCode}`,
+        rootSymbol,
+        expiry,
+        firstTradeDate: firstTrade,
+        lastTradeDate: lastTrade,
+        monthCode,
+        year,
+        tickSize: 0.1,
+        multiplier: 1e5,
+        exchange: "VNX"
+      });
+    }
+    return contracts;
+  }
+  function generateTestBarsWithRollGap(contracts, rollMethod, gapPercent = 0) {
+    const barsMap = /* @__PURE__ */ new Map();
+    let basePrice = 1e3;
+    for (let i = 0; i < contracts.length; i++) {
+      const contract = contracts[i];
+      const bars = [];
+      const days = Math.ceil((contract.lastTradeDate - contract.firstTradeDate) / (24 * 60 * 60 * 1e3));
+      if (i > 0 && gapPercent !== 0) {
+        const gapFactor = 1 + gapPercent / 100;
+        if (rollMethod === "ratio") {
+          basePrice *= gapFactor;
+        } else if (rollMethod === "panama") {
+          basePrice += basePrice * gapPercent / 100;
+        }
+      }
+      for (let d = 0; d < days; d++) {
+        const timestamp = contract.firstTradeDate + d * 24 * 60 * 60 * 1e3;
+        const date = new Date(timestamp);
+        if (date.getDay() === 0 || date.getDay() === 6) continue;
+        const volatility = 0.01;
+        const change = (Math.random() - 0.5) * 2 * volatility * basePrice;
+        basePrice = Math.max(10, basePrice + change);
+        const open = basePrice * (1 + (Math.random() - 0.5) * 3e-3);
+        const close = basePrice * (1 + (Math.random() - 0.5) * 3e-3);
+        const high = Math.max(open, close) * (1 + Math.random() * 3e-3);
+        const low = Math.min(open, close) * (1 - Math.random() * 3e-3);
+        const volume = Math.floor(1e4 + Math.random() * 5e4);
+        bars.push({ timestamp, open, high, low, close, volume });
+      }
+      barsMap.set(contract.symbol, bars);
+    }
+    return barsMap;
+  }
+  var init_rollAlgorithms = __esm({
+    "src/lib/adapters/rollAlgorithms.ts"() {
+    }
+  });
+
+  // src/widget/adapters/barsPagingPolicy.ts
+  function asFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = Number(value.trim());
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+  }
+  function resolveOldestBarTimestamp(bars) {
+    if (bars.length === 0) {
+      return null;
+    }
+    let oldest = Number.POSITIVE_INFINITY;
+    for (const bar of bars) {
+      const ts = bar.date instanceof Date ? bar.date.valueOf() : new Date(bar.date).valueOf();
+      if (Number.isFinite(ts) && ts < oldest) {
+        oldest = ts;
+      }
+    }
+    return Number.isFinite(oldest) ? oldest : null;
+  }
+  function normalizeBarsPagingMeta(payload, bars) {
+    const explicitHasMoreBefore = payload.has_more_before;
+    const explicitHasMoreAfter = payload.has_more_after;
+    const explicitNextBefore = asFiniteNumber(payload.next_before);
+    const explicitNextAfter = asFiniteNumber(payload.next_after);
+    const snapshotId = typeof payload.snapshot_id === "string" ? payload.snapshot_id : null;
+    const oldestBarTs = resolveOldestBarTimestamp(bars);
+    const nextBefore = explicitNextBefore ?? oldestBarTs;
+    const hasMoreBefore = typeof explicitHasMoreBefore === "boolean" ? explicitHasMoreBefore : nextBefore !== null;
+    const hasMoreAfter = typeof explicitHasMoreAfter === "boolean" ? explicitHasMoreAfter : false;
+    return {
+      hasMoreBefore,
+      hasMoreAfter,
+      nextBefore: hasMoreBefore ? nextBefore : null,
+      nextAfter: hasMoreAfter ? explicitNextAfter : null,
+      snapshotId
+    };
+  }
+  function buildBackwardPageRequest(meta, fallbackBefore, limit) {
+    if (!meta.hasMoreBefore) {
+      return null;
+    }
+    const before = meta.nextBefore ?? fallbackBefore;
+    if (!Number.isFinite(before)) {
+      return null;
+    }
+    return {
+      before,
+      limit,
+      snapshotId: meta.snapshotId ?? void 0
+    };
+  }
+
+  // src/widget/adapters/nativeShapes.ts
+  var BARS_LIMIT_MAX = 1e3;
+  function clampBarsLimit(raw) {
+    if (raw == null) return raw;
+    if (!Number.isFinite(raw)) return BARS_LIMIT_MAX;
+    return Math.max(1, Math.min(BARS_LIMIT_MAX, Math.floor(raw)));
+  }
+  var ORDER_FLOW_WINDOW_MINUTES = { "5m": 5, "15m": 15, "30m": 30, "1h": 60 };
+  var DARK_FLOW_SIGNAL_TYPES = ["none", "absorption", "iceberg", "twap_bot", "mixed"];
+  function parseDarkFlowSignalType(value) {
+    return typeof value === "string" && DARK_FLOW_SIGNAL_TYPES.includes(value) ? value : "none";
+  }
+  function asFiniteNumber2(value) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim() !== "") {
+      const parsed = Number(value);
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+  }
+  function mapNativeSignal(s) {
+    return {
+      id: typeof s["id"] === "number" || typeof s["id"] === "string" ? s["id"] : -1,
+      symbol: typeof s["symbol"] === "string" ? s["symbol"] : "",
+      signal_type: typeof s["signal_type"] === "string" ? s["signal_type"] : "unknown",
+      strength: asFiniteNumber2(s["strength"]) ?? 0,
+      confidence: asFiniteNumber2(s["confidence"]) ?? 0,
+      tick_rate: asFiniteNumber2(s["tick_rate"]) ?? 0,
+      small_order_ratio: asFiniteNumber2(s["small_order_ratio"]) ?? 0,
+      cvd_at_signal: asFiniteNumber2(s["cvd_at_signal"]),
+      price_at_signal: asFiniteNumber2(s["price_at_signal"]),
+      created_at: typeof s["created_at"] === "string" ? s["created_at"] : "",
+      event_id: typeof s["event_id"] === "string" ? s["event_id"] : null,
+      severity: typeof s["severity"] === "string" ? s["severity"] : void 0
+    };
+  }
+  function mapNativeOrderFlow(obj, window2) {
+    const rawSignals = Array.isArray(obj["signals"]) ? obj["signals"] : [];
+    const darkRaw = obj["dark_flow"] ?? {};
+    const latestRaw = obj["latest_signal"] ?? null;
+    return {
+      ok: true,
+      symbol: typeof obj["symbol"] === "string" ? obj["symbol"] : "",
+      window: typeof obj["window"] === "string" ? obj["window"] : window2,
+      window_minutes: ORDER_FLOW_WINDOW_MINUTES[window2] ?? 30,
+      latest_signal: latestRaw ? mapNativeSignal(latestRaw) : null,
+      signals: rawSignals.map(mapNativeSignal),
+      cvd_series: [],
+      dark_flow: {
+        signal_type: parseDarkFlowSignalType(darkRaw["signal_type"]),
+        strength: asFiniteNumber2(darkRaw["strength"]) ?? 0,
+        confidence: asFiniteNumber2(darkRaw["confidence"]) ?? 0,
+        components: darkRaw["components"],
+        triggered_at: typeof darkRaw["triggered_at"] === "string" ? darkRaw["triggered_at"] : null
+      },
+      tick_rate: obj["tick_rate"] ?? {},
+      size_distribution: obj["size_distribution"] ?? {}
+    };
+  }
+  var ZERO_WHALE_SUMMARY = {
+    buy_value: 0,
+    sell_value: 0,
+    shark_buy: 0,
+    shark_sell: 0,
+    whale_buy: 0,
+    whale_sell: 0,
+    small_buy: 0,
+    small_sell: 0
+  };
+  function mapNativeWhaleFeed(obj) {
+    const rawAlerts = Array.isArray(obj["alerts"]) ? obj["alerts"] : [];
+    const alerts = rawAlerts.map((a) => ({
+      id: typeof a["id"] === "string" ? a["id"] : "",
+      alert_type: typeof a["alert_type"] === "string" ? a["alert_type"] : "signal",
+      severity: typeof a["severity"] === "string" ? a["severity"] : "",
+      title: typeof a["title"] === "string" ? a["title"] : "",
+      value: typeof a["value"] === "string" || typeof a["value"] === "number" ? a["value"] : null,
+      direction: typeof a["direction"] === "string" ? a["direction"] : "",
+      triggered_at: typeof a["triggered_at"] === "string" ? a["triggered_at"] : ""
+    }));
+    return {
+      symbol: typeof obj["symbol"] === "string" ? obj["symbol"] : "",
+      whale_orders: [],
+      summary: { ...ZERO_WHALE_SUMMARY },
+      alerts
+    };
+  }
+  function mapNativeTape(obj) {
+    const rawTrades = Array.isArray(obj["trades"]) ? obj["trades"] : [];
+    const entries = rawTrades.map((t, index) => {
+      const price = asFiniteNumber2(t["price"]) ?? 0;
+      const volume = asFiniteNumber2(t["volume"]) ?? 0;
+      const sideRaw = typeof t["side"] === "string" ? t["side"].toLowerCase() : "";
+      const side = sideRaw === "buy" || sideRaw === "sell" ? sideRaw : "unknown";
+      const ts = typeof t["ts"] === "string" ? t["ts"] : typeof t["time"] === "string" ? t["time"] : "";
+      return {
+        id: `${ts}|${price}|${volume}|${index}`,
+        ts,
+        price,
+        volume,
+        value: price * volume,
+        side,
+        is_whale: false
+      };
+    });
+    return {
+      ok: true,
+      symbol: typeof obj["symbol"] === "string" ? obj["symbol"] : "",
+      entries
+    };
+  }
+
+  // src/lib/cache/cacheDebug.ts
+  typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+  var qs = () => typeof window !== "undefined" ? new URLSearchParams(window.location.search) : new URLSearchParams();
+  function getCacheTTL(defaultMs) {
+    const override = Number(qs().get("bars-ttl"));
+    return Number.isFinite(override) && override > 0 ? override : defaultMs;
+  }
+
+  // src/widget/history/historyDataUtils.ts
+  function resolveTimeframeMs(timeframe) {
+    const result = (() => {
+      switch (timeframe) {
+        case "1m":
+          return 6e4;
+        case "3m":
+          return 3 * 6e4;
+        case "5m":
+          return 5 * 6e4;
+        case "15m":
+          return 15 * 6e4;
+        case "30m":
+          return 30 * 6e4;
+        case "1h":
+          return 60 * 6e4;
+        case "2h":
+          return 2 * 60 * 6e4;
+        case "4h":
+          return 4 * 60 * 6e4;
+        case "1d":
+        case "1D":
+          return 24 * 60 * 6e4;
+        case "1w":
+        case "1W":
+          return 7 * 24 * 60 * 6e4;
+        case "1M":
+          return 30 * 24 * 60 * 6e4;
+        default:
+          return 24 * 60 * 6e4;
+      }
+    })();
+    return result;
+  }
+
+  // src/widget/data/DataEnvelope.ts
+  var NUMERIC_SENTINELS = /* @__PURE__ */ new Set(["", "-", "--", "N/A", "n/a", "null", "undefined", "NaN"]);
+  function toNum(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (NUMERIC_SENTINELS.has(trimmed)) return null;
+      const parsed = Number(trimmed);
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+  }
+  function toNumOrZero(value) {
+    const n = toNum(value);
+    return n === null ? 0 : n;
+  }
+  var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+  var NAIVE_DATETIME_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2})?(\.\d+)?$/;
+  function toTimestampMs(value) {
+    if (value instanceof Date) {
+      const t = value.getTime();
+      return Number.isFinite(t) ? t : null;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value) || value <= 0) return null;
+      return value < 1e11 ? Math.round(value * 1e3) : Math.round(value);
+    }
+    if (typeof value !== "string") return null;
+    const trimmed = value.trim();
+    if (NUMERIC_SENTINELS.has(trimmed)) return null;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return toTimestampMs(Number(trimmed));
+    if (DATE_ONLY_RE.test(trimmed)) return Date.parse(`${trimmed}T00:00:00Z`);
+    if (NAIVE_DATETIME_RE.test(trimmed)) {
+      const iso = trimmed.replace(" ", "T");
+      const withSeconds = iso.length === 16 ? `${iso}:00` : iso;
+      return Date.parse(`${withSeconds}Z`);
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  function readRecord(raw) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return raw;
+    }
+    return null;
+  }
+  function readBarTimestamp(rec) {
+    for (const key of ["timestamp", "date", "time", "t", "ts"]) {
+      const ms = toTimestampMs(rec[key]);
+      if (ms !== null) return ms;
+    }
+    return null;
+  }
+  function readBarSource(rec) {
+    if (rec.timestamp !== void 0) return "bars";
+    if (rec.date !== void 0 || rec.time !== void 0) return "chart";
+    return "unknown";
+  }
+  function normalizeBar(raw) {
+    const rec = readRecord(raw);
+    if (!rec) return null;
+    const timestamp = readBarTimestamp(rec);
+    if (timestamp === null) return null;
+    return {
+      timestamp,
+      open: toNum(rec.open ?? rec.o),
+      high: toNum(rec.high ?? rec.h),
+      low: toNum(rec.low ?? rec.l),
+      close: toNum(rec.close ?? rec.c),
+      volume: toNumOrZero(rec.volume ?? rec.v),
+      adjClose: toNum(rec.adj_close ?? rec.adjClose),
+      adjFactor: toNum(rec.adj_factor ?? rec.adjFactor),
+      isPartial: rec.isPartial === true || rec.is_partial === true,
+      source: readBarSource(rec)
+    };
+  }
+
+  // src/lib/utils/storage.ts
+  function getSafeStorage() {
+    try {
+      if (typeof localStorage === "undefined") return null;
+      return localStorage;
+    } catch {
+      return null;
+    }
+  }
+  function readString(key) {
+    const store = getSafeStorage();
+    if (!store) return null;
+    try {
+      return store.getItem(key);
+    } catch {
+      return null;
+    }
+  }
+  function writeString(key, value) {
+    const store = getSafeStorage();
+    if (!store) return false;
+    try {
+      store.setItem(key, value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function removeKey(key) {
+    const store = getSafeStorage();
+    if (!store) return false;
+    try {
+      store.removeItem(key);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // src/lib/credentials/credentialStore.ts
+  var LICENSE_STORAGE_KEY = "vni_license_key";
+  var PAT_STORAGE_KEY = "vni_pat";
+  var PENDING_MIGRATION_WARNING = "pending-license-migration";
+  var migrationState = "idle";
+  function isLicenseMigrationPending() {
+    return migrationState === "pending";
+  }
+  function isLicenseBlob(value) {
+    if (!value) return false;
+    return engineCore.parseLicenseKey(value) !== null;
+  }
+  function readRaw(key) {
+    return readString(key) ?? "";
+  }
+  function writeRaw(key, value) {
+    writeString(key, value);
+  }
+  function warnOnce(message) {
+    try {
+      if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return;
+    } catch {
+    }
+    console.warn(`[credentialStore] ${message}`);
+  }
+  function removeRaw(key) {
+    removeKey(key);
+  }
+  var sessionPat = null;
+  function readPat() {
+    if (sessionPat !== null) {
+      if (!sessionPat || isLicenseBlob(sessionPat)) return "";
+      return sessionPat;
+    }
+    const stored = readRaw(PAT_STORAGE_KEY);
+    if (!stored) return "";
+    if (isLicenseBlob(stored)) return "";
+    return stored;
+  }
+  function readSessionPat() {
+    if (sessionPat === null || !sessionPat || isLicenseBlob(sessionPat)) return "";
+    return sessionPat;
+  }
+  function writePat(value) {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed) {
+      clearPat();
+      return { ok: true };
+    }
+    if (isLicenseBlob(trimmed)) {
+      warnOnce("refused a license blob on the PAT channel");
+      return { ok: false, reason: "is-license-blob" };
+    }
+    if (isLicenseMigrationPending()) {
+      warnOnce(`${PENDING_MIGRATION_WARNING}: PAT not saved, a license key is still being migrated`);
+      return { ok: false, reason: "migration-pending" };
+    }
+    sessionPat = trimmed;
+    writeRaw(PAT_STORAGE_KEY, trimmed);
+    return { ok: true };
+  }
+  function clearPat() {
+    sessionPat = null;
+    removeRaw(PAT_STORAGE_KEY);
+  }
+  var inFlight = null;
+  async function migrateLegacyLicenseSlot() {
+    if (inFlight) return inFlight;
+    migrationState = "pending";
+    inFlight = (async () => {
+      if (readRaw(LICENSE_STORAGE_KEY)) return { migrated: false, reason: "already-migrated" };
+      const stored = readRaw(PAT_STORAGE_KEY);
+      if (!stored) return { migrated: false, reason: "not-a-license" };
+      if (!isLicenseBlob(stored)) return { migrated: false, reason: "not-a-license" };
+      writeRaw(LICENSE_STORAGE_KEY, stored);
+      const verified = await engineCore.verifyLicenseKey(stored, { host: typeof location !== "undefined" ? location.hostname : "" });
+      if (verified) {
+        if (readRaw(LICENSE_STORAGE_KEY) === stored) ;
+        if (readRaw(PAT_STORAGE_KEY) === stored) {
+          sessionPat = null;
+          removeRaw(PAT_STORAGE_KEY);
+        }
+        return { migrated: true, reason: "already-migrated" };
+      }
+      if (readRaw(LICENSE_STORAGE_KEY) === stored) {
+        removeRaw(LICENSE_STORAGE_KEY);
+      }
+      return { migrated: false, reason: "verify-failed" };
+    })();
+    try {
+      return await inFlight;
+    } finally {
+      inFlight = null;
+      migrationState = "settled";
+    }
+  }
+  void migrateLegacyLicenseSlot();
+
+  // src/widget/adapters/VNInvestClient.ts
+  var API_BASE_STORAGE_KEY = "vni_api_base";
+  var DEFAULT_API_BASE = "https://127.0.0.1";
+  var DEFAULT_PAT = "";
+  function normalizeApiBase(value) {
+    const trimmed = value.trim();
+    return trimmed.replace(/\/+$/, "");
+  }
+  function resolveBrowserOrigin() {
+    try {
+      if (typeof location === "undefined" || typeof location.origin !== "string") {
+        return null;
+      }
+      const normalizedOrigin = normalizeApiBase(location.origin);
+      if (!/^https?:\/\//i.test(normalizedOrigin)) {
+        return null;
+      }
+      return normalizedOrigin;
+    } catch {
+      return null;
+    }
+  }
+  function resolveApiBase() {
+    try {
+      const globalScope = globalThis;
+      if (typeof globalScope.__VNI_API_BASE__ === "string") {
+        return normalizeApiBase(globalScope.__VNI_API_BASE__);
+      }
+    } catch {
+    }
+    try {
+      if (typeof localStorage !== "undefined") {
+        const stored = localStorage.getItem(API_BASE_STORAGE_KEY);
+        if (stored) return normalizeApiBase(stored);
+      }
+    } catch {
+    }
+    const browserOrigin = resolveBrowserOrigin();
+    if (browserOrigin) {
+      return browserOrigin;
+    }
+    return DEFAULT_API_BASE;
+  }
+  var TIMEFRAME_MAP = {
+    "1m": "1m",
+    "5m": "5m",
+    "15m": "15m",
+    "1h": "1H",
+    "1H": "1H",
+    "2H": "2H",
+    "4H": "4H",
+    "1d": "D",
+    "1D": "D",
+    "d": "D",
+    "D": "D",
+    "W": "W",
+    "M": "M",
+    "Y": "Y"
+  };
+  function normalizeTimeframe(tf) {
+    const result = TIMEFRAME_MAP[tf] ?? tf;
+    return result;
+  }
+  function isCurrentCandleResponse(response, timeframe) {
+    const bars = response.bars;
+    if (bars.length === 0) return false;
+    const lastBar = bars[bars.length - 1];
+    const tfMs = resolveTimeframeMs(timeframe);
+    return Date.now() - lastBar.date.getTime() < tfMs;
+  }
+  function asObject(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return null;
+  }
+  function normalizeChartPoint(value) {
+    const bar = normalizeBar(value);
+    if (!bar) return null;
+    if (bar.open === null || bar.high === null || bar.low === null || bar.close === null) {
+      return null;
+    }
+    return {
+      date: new Date(bar.timestamp).toISOString(),
+      open: bar.open,
+      high: bar.high,
+      low: bar.low,
+      close: bar.close,
+      volume: bar.volume
+    };
+  }
+  function extractChartPoints(data) {
+    if (Array.isArray(data)) {
+      return data.map(normalizeChartPoint).filter((point) => point !== null);
+    }
+    const payload = asObject(data);
+    if (!payload) {
+      return [];
+    }
+    const nestedData = asObject(payload.data);
+    const candidates = [
+      payload.points,
+      nestedData?.points,
+      payload.candles,
+      nestedData?.candles,
+      payload.ohlcv,
+      nestedData?.ohlcv,
+      payload.results,
+      nestedData?.results,
+      payload.data
+    ];
+    for (const candidate of candidates) {
+      if (!Array.isArray(candidate)) {
+        continue;
+      }
+      const normalized = candidate.map(normalizeChartPoint).filter((point) => point !== null);
+      if (normalized.length > 0 || candidate.length === 0) {
+        return normalized;
+      }
+    }
+    return [];
+  }
+  function resolveTechnical(data) {
+    if (Array.isArray(data)) {
+      return void 0;
+    }
+    const payload = asObject(data);
+    if (!payload) {
+      return void 0;
+    }
+    const nestedData = asObject(payload.data);
+    const technical = payload.technical ?? nestedData?.technical;
+    return technical;
+  }
+  function normalizeChartBars(data) {
+    const points = extractChartPoints(data);
+    const technical = resolveTechnical(data);
+    return points.map((point) => ({
+      date: new Date(point.date),
+      open: point.open,
+      high: point.high,
+      low: point.low,
+      close: point.close,
+      volume: point.volume,
+      technical
+    })).filter((bar) => Number.isFinite(bar.date.valueOf()));
+  }
+  function isWhaleFeedResponse(data) {
+    if (!data || Array.isArray(data) || typeof data !== "object") {
+      return false;
+    }
+    return "summary" in data && "whale_orders" in data;
+  }
+  function buildEndpoints(base) {
+    return {
+      CHART: (symbol) => `${base}/core/v1/stock-management/stocks/${encodeURIComponent(symbol)}/chart/`,
+      BARS: (symbol) => `${base}/core/v1/stock-management/stocks/${encodeURIComponent(symbol)}/bars/`,
+      ORDER_FLOW: (symbol) => `${base}/core/v1/stock-management/stocks/${encodeURIComponent(symbol)}/order-flow/`,
+      STOCKS_LIST: `${base}/core/v1/stock-management/stocks/`,
+      AUTH_TOKEN: `${base}/core/v1/auth/token/`,
+      AUTH_ME: `${base}/core/v1/auth/me`,
+      TICKER: (symbol) => `${base}/core/v1/realtime/ticker/${encodeURIComponent(symbol)}/`,
+      WHALE_FEED: (symbol) => `${base}/core/v1/realtime/whale-feed/${encodeURIComponent(symbol)}/`,
+      AI_ADVISORY: `${base}/core/v1/stock_ai_advisory_session/`,
+      // Decision A (follow-up): native advisory session — GET reads, POST triggers refresh.
+      AI_ADVISORY_V2: (symbol) => `${base}/core/v1/stock-management/stocks/${encodeURIComponent(symbol)}/ai-advisory-session/`,
+      // BE-03: backend serves path-param style only: /intraday-tape/{symbol}/
+      // (verified live 2026-09-21; the old ?symbol= style 404s).
+      INTRADAY_TAPE: (symbol) => `${base}/core/v1/market-data/intraday-tape/${encodeURIComponent(symbol)}/`,
+      WIDGET_AD: `${base}/core/v1/widget/ad`
+    };
+  }
+  var BARS_HOT_WINDOW_TTL_MS = 15e3;
+  var BARS_HOT_WINDOW_STALE_MS = 6e4;
+  var barsHotWindowCache = /* @__PURE__ */ new Map();
+  var barsHotWindowInFlight = /* @__PURE__ */ new Map();
+  var barsHotWindowTelemetry = {
+    cacheHits: 0,
+    inFlightCollapses: 0,
+    networkRequests: 0,
+    lastUpdatedAt: null
+  };
+  function markBarsHotWindowTelemetry(metric) {
+    barsHotWindowTelemetry[metric] += 1;
+    barsHotWindowTelemetry.lastUpdatedAt = Date.now();
+  }
+  function cloneBarsHotWindowTelemetry(telemetry) {
+    return {
+      cacheHits: telemetry.cacheHits,
+      inFlightCollapses: telemetry.inFlightCollapses,
+      networkRequests: telemetry.networkRequests,
+      lastUpdatedAt: telemetry.lastUpdatedAt
+    };
+  }
+  function createBarsHotWindowKey(base, pat, params) {
+    const scope = [base, pat, params.symbol.trim().toUpperCase(), normalizeTimeframe(params.timeframe)].join("|");
+    if (params.type === "backward") {
+      return `${scope}|backward|${params.before}|${params.limit}|${params.snapshotId ?? ""}`;
+    }
+    return `${scope}|init|${params.from ?? ""}|${params.to ?? ""}|${params.limit ?? ""}`;
+  }
+  function cloneBarsPageResponse(response) {
+    return {
+      bars: response.bars.map((bar) => ({
+        date: new Date(bar.date),
+        open: bar.open,
+        high: bar.high,
+        low: bar.low,
+        close: bar.close,
+        volume: bar.volume,
+        technical: bar.technical
+      })),
+      hasMoreBefore: response.hasMoreBefore,
+      hasMoreAfter: response.hasMoreAfter,
+      nextBefore: response.nextBefore,
+      nextAfter: response.nextAfter,
+      snapshotId: response.snapshotId
+    };
+  }
+  function pruneExpiredBarsHotWindowEntries(now) {
+    for (const [key, entry] of barsHotWindowCache.entries()) {
+      if (entry.expiresAt <= now) {
+        barsHotWindowCache.delete(key);
+      }
+    }
+  }
+  async function revalidateBarsHotWindow(base, pat, cacheKey, params) {
+    const endpoints = buildEndpoints(base);
+    const urlParams = new URLSearchParams();
+    urlParams.set("timeframe", normalizeTimeframe(params.timeframe));
+    if (params.type === "backward") {
+      urlParams.set("before", String(params.before));
+      urlParams.set("limit", String(params.limit));
+      if (params.snapshotId) urlParams.set("snapshot_id", params.snapshotId);
+    } else {
+      if (params.from != null) urlParams.set("from", String(params.from));
+      if (params.to != null) urlParams.set("to", String(params.to));
+      if (params.limit != null) urlParams.set("limit", String(params.limit));
+    }
+    try {
+      markBarsHotWindowTelemetry("networkRequests");
+      const url = `${endpoints.BARS(params.symbol)}?${urlParams.toString()}`;
+      const authHeaders = {};
+      if (pat) authHeaders["Authorization"] = `Bearer ${pat}`;
+      const response = await globalThis.fetch(url, { headers: authHeaders });
+      if (!response.ok) return;
+      const data = await response.json();
+      const rawBars = Array.isArray(data?.bars) ? data.bars : [];
+      const bars = rawBars.map(normalizeChartPoint).filter((p) => p !== null).map((point) => ({
+        date: new Date(point.date),
+        open: point.open,
+        high: point.high,
+        low: point.low,
+        close: point.close,
+        volume: point.volume
+      })).filter((bar) => Number.isFinite(bar.date.valueOf()));
+      const pagingMeta = normalizeBarsPagingMeta(data, bars);
+      const swrResponse = {
+        bars,
+        hasMoreBefore: pagingMeta.hasMoreBefore,
+        hasMoreAfter: pagingMeta.hasMoreAfter,
+        nextBefore: pagingMeta.nextBefore,
+        nextAfter: pagingMeta.nextAfter,
+        snapshotId: pagingMeta.snapshotId
+      };
+      const ttl = getCacheTTL(BARS_HOT_WINDOW_TTL_MS);
+      const now = Date.now();
+      if (!isCurrentCandleResponse(swrResponse, params.timeframe)) {
+        barsHotWindowCache.set(cacheKey, {
+          response: cloneBarsPageResponse(swrResponse),
+          expiresAt: now + ttl,
+          fetchedAt: now
+        });
+      }
+    } catch {
+    }
+  }
+  var VNInvestClient = class _VNInvestClient {
+    _pat = "";
+    _base;
+    _authHandler;
+    constructor(patToken) {
+      this._base = resolveApiBase();
+      try {
+        if (typeof globalThis !== "undefined") {
+          const globalPat = globalThis.__VNI_PAT_TOKEN__;
+          if (typeof globalPat === "string" && globalPat.trim()) {
+            this._pat = globalPat.trim();
+            writePat(this._pat);
+            return;
+          }
+        }
+      } catch {
+      }
+      try {
+        if (typeof localStorage !== "undefined") {
+          const stored = localStorage.getItem(PAT_STORAGE_KEY);
+          if (stored) {
+            const isLicenseKey = !!engineCore.parseLicenseKey(stored);
+            if (!DEFAULT_PAT && !isLicenseKey) {
+              const migrationKey = "vni_pat_cleared_v1";
+              if (!localStorage.getItem(migrationKey)) {
+                clearPat();
+                localStorage.removeItem("vninvest_saas_features_vni_internal_Q3zRGQ2bpLoLjGdYx6R72E7TH50tQ2iIYRUecgSKfDnirANYBGQrM2wQlZQ12uP6");
+                localStorage.setItem(migrationKey, "1");
+              }
+            } else {
+              const token = readPat();
+              if (token) {
+                this._pat = token;
+                return;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      if (patToken) {
+        this.setPAT(patToken);
+        return;
+      }
+      if (!this._pat) {
+        const mem = readSessionPat();
+        if (mem) this._pat = mem;
+      }
+    }
+    setAuthHandler(handler) {
+      this._authHandler = handler;
+    }
+    setPAT(token) {
+      const trimmed = (token ?? "").trim();
+      const changed = trimmed !== this._pat;
+      if (!trimmed) {
+        this._pat = "";
+        clearPat();
+        if (changed) this._notifyPatChanged();
+        return;
+      }
+      const result = writePat(trimmed);
+      if (!result.ok) return;
+      this._pat = trimmed;
+      if (changed) this._notifyPatChanged();
+    }
+    /**
+     * Transport-only credential sync. Sets `_pat` WITHOUT touching storage —
+     * storage belongs to credentialStore alone. The SaaS context calls this before
+     * validation when its resolved credential (tenant > user > env) differs from
+     * what this transport carries; otherwise a user-pasted PAT sits in storage
+     * while requests go out with a stale or empty token, and the backend 401s with
+     * "Authentication credentials were not provided." No-op when equal.
+     */
+    syncTransportPat(token) {
+      const trimmed = (token ?? "").trim();
+      if (trimmed === this._pat) return;
+      this._pat = trimmed;
+      this._notifyPatChanged();
+    }
+    _notifyPatChanged() {
+      try {
+        window.dispatchEvent(new CustomEvent("vni:pat-changed"));
+      } catch {
+      }
+    }
+    getPAT() {
+      return this._pat;
+    }
+    setBase(url) {
+      const trimmed = (url ?? "").trim().replace(/\/+$/, "");
+      if (!trimmed) return;
+      this._base = trimmed;
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.setItem(API_BASE_STORAGE_KEY, trimmed);
+        }
+      } catch {
+      }
+    }
+    getBase() {
+      return this._base;
+    }
+    hasPAT() {
+      return this._pat.length > 0;
+    }
+    buildHeaders() {
+      const headers = { "Content-Type": "application/json" };
+      if (this._pat) {
+        headers["Authorization"] = `Bearer ${this._pat}`;
+      }
+      return headers;
+    }
+    async _fetch(url, init, isRetry = false) {
+      const response = await fetch(url, { ...init, headers: this.buildHeaders() });
+      if (response.status === 401) {
+        if (!isRetry && this._authHandler) {
+          try {
+            const currentToken = await this._authHandler.getToken();
+            if (currentToken && currentToken.trim() !== this._pat) {
+              this.setPAT(currentToken);
+              return await this._fetch(url, init, true);
+            }
+            if (this._authHandler.getRefreshToken) {
+              const refreshToken = await this._authHandler.getRefreshToken();
+              if (refreshToken) {
+                const refreshUrl = `${this._base}/api/auth/token/refresh/`;
+                const refreshResponse = await fetch(refreshUrl, {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({ refresh: refreshToken })
+                });
+                if (refreshResponse.ok) {
+                  const data = await refreshResponse.json();
+                  const newPat = data.access || data.token || data.patToken;
+                  if (newPat) {
+                    this.setPAT(newPat);
+                    await this._authHandler.onTokensUpdated?.({
+                      patToken: newPat,
+                      refreshToken: data.refresh || refreshToken
+                    });
+                    return await this._fetch(url, init, true);
+                  }
+                }
+              }
+            }
+          } catch (refreshError) {
+            console.warn("Auto-refresh token failed in VNInvestClient:", refreshError);
+          }
+          this._authHandler.onAuthError?.(new Error("TOKEN_EXPIRED"));
+        }
+        const err = new Error("TOKEN_EXPIRED");
+        try {
+          const body = await response.clone().json();
+          if (typeof body?.detail === "string" && body.detail) {
+            err.detail = body.detail;
+          }
+        } catch {
+        }
+        throw err;
+      }
+      if (response.status === 404) {
+        throw new Error("SYMBOL_NOT_FOUND");
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => String(response.status));
+        throw new Error(`HTTP_${response.status}: ${text.slice(0, 200)}`);
+      }
+      return response.json();
+    }
+    async getChart(symbol, options) {
+      const endpoints = buildEndpoints(this._base);
+      const params = new URLSearchParams();
+      if (options?.timeframe) params.set("timeframe", normalizeTimeframe(options.timeframe));
+      if (options?.days != null) params.set("days", String(options.days));
+      const url = `${endpoints.CHART(symbol)}?${params.toString()}`;
+      const data = await this._fetch(url);
+      return normalizeChartBars(data);
+    }
+    async validateMe() {
+      const endpoints = buildEndpoints(this._base);
+      return this._fetch(endpoints.AUTH_ME);
+    }
+    /** Fetch eligible ad campaigns. Bearer PAT auto-attached; premium → empty list. */
+    async fetchAd() {
+      const endpoints = buildEndpoints(this._base);
+      return this._fetch(endpoints.WIDGET_AD);
+    }
+    async getBarsPage(params) {
+      const cacheKey = createBarsHotWindowKey(this._base, this._pat, params);
+      const now = Date.now();
+      pruneExpiredBarsHotWindowEntries(now);
+      const tfMs = resolveTimeframeMs(params.timeframe);
+      const isNearNow = params.type === "init" && params.to != null ? now - params.to < tfMs : false;
+      if (!isNearNow) {
+        const cachedEntry = barsHotWindowCache.get(cacheKey);
+        if (cachedEntry && cachedEntry.expiresAt > now) {
+          markBarsHotWindowTelemetry("cacheHits");
+          return cloneBarsPageResponse(cachedEntry.response);
+        }
+        if (cachedEntry && now - cachedEntry.fetchedAt < BARS_HOT_WINDOW_STALE_MS) {
+          markBarsHotWindowTelemetry("cacheHits");
+          void this._revalidateBarsHotWindow(cacheKey, params);
+          return cloneBarsPageResponse(cachedEntry.response);
+        }
+      }
+      const inFlight2 = barsHotWindowInFlight.get(cacheKey);
+      if (inFlight2) {
+        markBarsHotWindowTelemetry("inFlightCollapses");
+        const sharedResponse = await inFlight2;
+        return cloneBarsPageResponse(sharedResponse);
+      }
+      const endpoints = buildEndpoints(this._base);
+      const urlParams = new URLSearchParams();
+      urlParams.set("timeframe", normalizeTimeframe(params.timeframe));
+      const safeLimit = clampBarsLimit;
+      if (params.type === "backward") {
+        urlParams.set("before", String(params.before));
+        urlParams.set("limit", String(safeLimit(params.limit) ?? BARS_LIMIT_MAX));
+        if (params.snapshotId) urlParams.set("snapshot_id", params.snapshotId);
+      } else {
+        if (params.from != null) urlParams.set("from", String(params.from));
+        if (params.to != null) urlParams.set("to", String(params.to));
+        if (params.limit != null) urlParams.set("limit", String(safeLimit(params.limit)));
+      }
+      const requestPromise = (async () => {
+        markBarsHotWindowTelemetry("networkRequests");
+        const url = `${endpoints.BARS(params.symbol)}?${urlParams.toString()}`;
+        const data = await this._fetch(url);
+        const payload = data;
+        const rawBars = Array.isArray(payload?.bars) ? payload.bars : [];
+        const bars = rawBars.map(normalizeChartPoint).filter((p) => p !== null).map((point) => ({
+          date: new Date(point.date),
+          open: point.open,
+          high: point.high,
+          low: point.low,
+          close: point.close,
+          volume: point.volume
+        })).filter((bar) => Number.isFinite(bar.date.valueOf()));
+        const pagingMeta = normalizeBarsPagingMeta(payload, bars);
+        const response = {
+          bars,
+          hasMoreBefore: pagingMeta.hasMoreBefore,
+          hasMoreAfter: pagingMeta.hasMoreAfter,
+          nextBefore: pagingMeta.nextBefore,
+          nextAfter: pagingMeta.nextAfter,
+          snapshotId: pagingMeta.snapshotId
+        };
+        const ttl = getCacheTTL(BARS_HOT_WINDOW_TTL_MS);
+        const now2 = Date.now();
+        if (!isCurrentCandleResponse(response, params.timeframe)) {
+          barsHotWindowCache.set(cacheKey, {
+            response: cloneBarsPageResponse(response),
+            expiresAt: now2 + ttl,
+            fetchedAt: now2
+          });
+        }
+        return response;
+      })();
+      barsHotWindowInFlight.set(cacheKey, requestPromise);
+      try {
+        const response = await requestPromise;
+        return cloneBarsPageResponse(response);
+      } finally {
+        barsHotWindowInFlight.delete(cacheKey);
+      }
+    }
+    static __resetBarsHotWindowCacheForTests() {
+      barsHotWindowCache.clear();
+      barsHotWindowInFlight.clear();
+      barsHotWindowTelemetry.cacheHits = 0;
+      barsHotWindowTelemetry.inFlightCollapses = 0;
+      barsHotWindowTelemetry.networkRequests = 0;
+      barsHotWindowTelemetry.lastUpdatedAt = null;
+    }
+    static getBarsHotWindowTelemetry() {
+      return cloneBarsHotWindowTelemetry(barsHotWindowTelemetry);
+    }
+    static __getBarsHotWindowTelemetryForTests() {
+      return _VNInvestClient.getBarsHotWindowTelemetry();
+    }
+    async getStocks(query, exchange) {
+      const endpoints = buildEndpoints(this._base);
+      const params = new URLSearchParams();
+      if (query) params.set("search", query);
+      if (exchange) params.set("exchange", exchange);
+      const url = `${endpoints.STOCKS_LIST}?${params.toString()}`;
+      const data = await this._fetch(url);
+      if (Array.isArray(data)) return data;
+      if ("results" in data && Array.isArray(data.results)) return data.results;
+      return [];
+    }
+    async getWhaleFeed(symbol) {
+      const endpoints = buildEndpoints(this._base);
+      const data = await this._fetch(endpoints.WHALE_FEED(symbol));
+      if (isWhaleFeedResponse(data)) return data;
+      const obj = data;
+      if (obj && typeof obj === "object" && typeof obj["symbol"] === "string" && Array.isArray(obj["alerts"])) {
+        return mapNativeWhaleFeed(obj);
+      }
+      return null;
+    }
+    async getOrderFlow(symbol, window2 = "30m") {
+      const endpoints = buildEndpoints(this._base);
+      const params = new URLSearchParams({ window: window2 });
+      const url = `${endpoints.ORDER_FLOW(symbol)}?${params.toString()}`;
+      const data = await this._fetch(url);
+      const obj = data;
+      if (!obj || typeof obj !== "object") {
+        return null;
+      }
+      if (obj["ok"] === true) {
+        return obj;
+      }
+      if (typeof obj["symbol"] === "string" && (Array.isArray(obj["signals"]) || typeof obj["dark_flow"] === "object")) {
+        return mapNativeOrderFlow(obj, window2);
+      }
+      return null;
+    }
+    /** Shared GET/POST fetch for the native advisory session endpoint. */
+    async fetchAdvisorySessionV2(url, init) {
+      const data = await this._fetch(url, init).catch(() => null);
+      const obj = data;
+      if (!obj || typeof obj !== "object" || typeof obj["symbol"] !== "string") {
+        return null;
+      }
+      return obj;
+    }
+    /**
+     * Follow-up advisory V2: read the native AI advisory session.
+     * Returns the session in both empty (`reason: "no_advisory_data"`) and record states;
+     * null only on transport/auth failure. Never throws for empty sessions.
+     */
+    async getAdvisorySessionV2(symbol) {
+      return this.fetchAdvisorySessionV2(buildEndpoints(this._base).AI_ADVISORY_V2(symbol));
+    }
+    /**
+     * Follow-up advisory V2: trigger a manual refresh (queues generation server-side).
+     * Returns the updated session payload; null on transport/auth failure.
+     */
+    async refreshAdvisorySession(symbol) {
+      return this.fetchAdvisorySessionV2(buildEndpoints(this._base).AI_ADVISORY_V2(symbol), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({})
+      });
+    }
+    /** @deprecated Legacy POST path 404s on current backends — use getAdvisorySessionV2. */
+    async getAdvisorySession(symbol) {
+      const endpoints = buildEndpoints(this._base);
+      const data = await this._fetch(endpoints.AI_ADVISORY, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ symbol })
+      });
+      const obj = data;
+      if (!obj || obj["ok"] !== true) {
+        return null;
+      }
+      return obj;
+    }
+    async getTapeEntries(symbol, pageSize = 100) {
+      const endpoints = buildEndpoints(this._base);
+      const url = `${endpoints.INTRADAY_TAPE(symbol)}?page_size=${Math.max(1, Math.min(200, Math.floor(pageSize)))}`;
+      const data = await this._fetch(url);
+      const obj = data;
+      if (!obj || typeof obj !== "object") {
+        return null;
+      }
+      if (obj["ok"] === true) {
+        return obj;
+      }
+      if (typeof obj["symbol"] === "string" && Array.isArray(obj["trades"])) {
+        return mapNativeTape(obj);
+      }
+      return null;
+    }
+    async _revalidateBarsHotWindow(cacheKey, params) {
+      await revalidateBarsHotWindow(this._base, this._pat, cacheKey, params);
+    }
+  };
+
+  // src/widget/adapters/VNInvestWebSocketClient.ts
+  function unwrapWsEnvelope(parsed) {
+    const data = parsed["data"];
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return parsed;
+    }
+    const body = { ...data };
+    for (const key of ["event_type", "symbol", "ts", "seq"]) {
+      if (body[key] === void 0 && parsed[key] !== void 0) {
+        body[key] = parsed[key];
+      }
+    }
+    return body;
+  }
+  var VNInvestWebSocketClient = class _VNInvestWebSocketClient {
+    static MAX_RECONNECT_ATTEMPTS = 5;
+    static RECONNECT_DELAY_MS = 5e3;
+    static WS_PATH_CANDIDATES = ["/ws/realtime/", "/api/realtime/ws/"];
+    ws = null;
+    pat;
+    apiBase;
+    selectedWsPath = null;
+    wsUnavailable = false;
+    wsProbePromise = null;
+    subscribedSymbols = /* @__PURE__ */ new Set();
+    onTickerUpdateCb = null;
+    onWhaleAlertCb = null;
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    _isConnected = false;
+    _destroyed = false;
+    constructor(pat, apiBase = resolveApiBase()) {
+      this.pat = pat;
+      this.apiBase = apiBase;
+    }
+    get isConnected() {
+      return this._isConnected;
+    }
+    get destroyed() {
+      return this._destroyed;
+    }
+    buildWsUrl(path = "/ws/realtime/") {
+      const wsBase = this.apiBase.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://").replace(/\/$/, "");
+      return `${wsBase}${path}?token=${encodeURIComponent(this.pat)}`;
+    }
+    buildHttpProbeUrl(path) {
+      const httpBase = this.apiBase.replace(/\/$/, "");
+      return `${httpBase}${path}`;
+    }
+    async probeWsPath(path) {
+      try {
+        const response = await fetch(this.buildHttpProbeUrl(path), {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${this.pat}`
+          }
+        });
+        if (response.status === 404 || response.status === 502 || response.status === 503) {
+          return false;
+        }
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    async resolveWsPath() {
+      if (this.selectedWsPath) {
+        return this.selectedWsPath;
+      }
+      try {
+        const hostname = new URL(this.apiBase).hostname;
+        if (hostname.endsWith(".test")) {
+          this.selectedWsPath = _VNInvestWebSocketClient.WS_PATH_CANDIDATES[0];
+          return this.selectedWsPath;
+        }
+      } catch {
+      }
+      if (this.wsProbePromise) {
+        return this.wsProbePromise;
+      }
+      this.wsProbePromise = (async () => {
+        for (const candidate of _VNInvestWebSocketClient.WS_PATH_CANDIDATES) {
+          const available = candidate === "/ws/realtime/" ? true : await this.probeWsPath(candidate);
+          if (available) {
+            this.selectedWsPath = candidate;
+            return candidate;
+          }
+        }
+        this.wsUnavailable = true;
+        return null;
+      })();
+      const resolved = await this.wsProbePromise;
+      this.wsProbePromise = null;
+      return resolved;
+    }
+    connect() {
+      if (this._destroyed || this.ws !== null || this.wsUnavailable) {
+        return;
+      }
+      void this.openConnection();
+    }
+    async openConnection() {
+      if (this._destroyed || this.ws !== null || this.wsUnavailable) {
+        return;
+      }
+      const wsPath = await this.resolveWsPath();
+      if (!wsPath || this._destroyed || this.wsUnavailable) {
+        return;
+      }
+      const url = this.buildWsUrl(wsPath);
+      try {
+        this.ws = new WebSocket(url);
+      } catch {
+        this.scheduleReconnect();
+        return;
+      }
+      this.ws.onopen = () => {
+        this.reconnectAttempts = 0;
+        this._isConnected = true;
+        const symbols = Array.from(this.subscribedSymbols);
+        if (symbols.length > 0) {
+          this.sendJson({ action: "subscribe", symbols });
+        }
+      };
+      this.ws.onmessage = (event) => {
+        this.handleRawMessage(event.data);
+      };
+      this.ws.onclose = (event) => {
+        this.ws = null;
+        this._isConnected = false;
+        if (event.code === 4401) {
+          return;
+        }
+        this.scheduleReconnect();
+      };
+      this.ws.onerror = () => {
+      };
+    }
+    subscribe(symbols) {
+      const normalized = symbols.map((s) => s.trim().toUpperCase()).filter(Boolean);
+      for (const sym of normalized) {
+        this.subscribedSymbols.add(sym);
+      }
+      if (this._isConnected && normalized.length > 0) {
+        this.sendJson({ action: "subscribe", symbols: normalized });
+      }
+    }
+    unsubscribe(symbols) {
+      const normalized = symbols.map((s) => s.trim().toUpperCase()).filter(Boolean);
+      for (const sym of normalized) {
+        this.subscribedSymbols.delete(sym);
+      }
+      if (this._isConnected && normalized.length > 0) {
+        this.sendJson({ action: "unsubscribe", symbols: normalized });
+      }
+    }
+    setOnTickerUpdate(cb) {
+      this.onTickerUpdateCb = cb;
+    }
+    setOnWhaleAlert(cb) {
+      this.onWhaleAlertCb = cb;
+    }
+    destroy() {
+      this._destroyed = true;
+      if (this.reconnectTimer !== null) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      if (this.ws !== null) {
+        this.ws.onclose = null;
+        this.ws.onmessage = null;
+        this.ws.onerror = null;
+        this.ws.onopen = null;
+        try {
+          this.ws.close(1e3, "destroy");
+        } catch {
+        }
+        this.ws = null;
+      }
+      this._isConnected = false;
+    }
+    handleRawMessage(data) {
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        return;
+      }
+      const body = unwrapWsEnvelope(parsed);
+      if (body.event_type === "ticker_update") {
+        this.onTickerUpdateCb?.(body);
+      } else if (body.event_type === "whale_alert") {
+        this.onWhaleAlertCb?.(body);
+      }
+    }
+    scheduleReconnect() {
+      if (this._destroyed || this.wsUnavailable || this.reconnectAttempts >= _VNInvestWebSocketClient.MAX_RECONNECT_ATTEMPTS) {
+        return;
+      }
+      this.reconnectAttempts += 1;
+      const delay = _VNInvestWebSocketClient.RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempts - 1);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        if (!this._destroyed) {
+          this.connect();
+        }
+      }, delay);
+    }
+    sendJson(msg) {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify(msg));
+      }
+    }
+  };
+
+  // src/widget/adapters/VNInvestDataAdapter.ts
+  var PAGE_LIMIT = 1e3;
+  var VNInvestDataAdapter = class {
+    name = "vninvest";
+    client;
+    wsClient = null;
+    barSubscribers = /* @__PURE__ */ new Map();
+    snapshotIds = /* @__PURE__ */ new Map();
+    lastBackfillCoverageMap = /* @__PURE__ */ new Map();
+    lastRangeCoverageMap = /* @__PURE__ */ new Map();
+    constructor(config) {
+      this.client = new VNInvestClient(config.patToken);
+      if (config.apiBase) {
+        this.client.setBase(config.apiBase);
+      }
+    }
+    setAuthHandler(handler) {
+      this.client.setAuthHandler(handler);
+    }
+    getSourceSemantics() {
+      return {
+        sourceId: this.name,
+        sourceContractVersion: "vninvest-backfill-v1",
+        instrumentClass: "equity",
+        coverageMode: "exact-range",
+        sessionModel: "exchange-calendar",
+        timezone: "Asia/Ho_Chi_Minh",
+        sessionCalendarId: "vn-exchange-calendar",
+        supportsExactRangeFetch: true,
+        supportsBackwardAnchor: true,
+        supportsForwardAnchor: false,
+        supportsLiveBars: true,
+        maxBarsPerRequest: PAGE_LIMIT,
+        finalityMode: "historically-correctable",
+        correctionLookbackMs: 30 * 864e5,
+        expectedGapReasons: ["not-fetched", "market-closed", "source-no-data", "rate-limited", "boundary-exhausted"]
+      };
+    }
+    coverageKey(symbol, timeframe, chartId) {
+      const scope = chartId ?? "__global__";
+      return `${scope}:${symbol.toUpperCase()}:${timeframe}`;
+    }
+    getLastBackfillCoverage(symbol, timeframe, chartId) {
+      if (!symbol || !timeframe) {
+        return null;
+      }
+      const key = this.coverageKey(symbol, timeframe, chartId);
+      return this.lastBackfillCoverageMap.get(key) ?? null;
+    }
+    getLastRangeCoverage(symbol, timeframe, chartId) {
+      if (!symbol || !timeframe) {
+        return null;
+      }
+      const key = this.coverageKey(symbol, timeframe, chartId);
+      return this.lastRangeCoverageMap.get(key) ?? null;
+    }
+    /** Expose the underlying REST client for advanced use cases. */
+    get restClient() {
+      return this.client;
+    }
+    /**
+     * Fetch bars in a date range.
+     * Uses the cursor-paged /bars/ endpoint with backward pagination.
+     *
+     * 504-guard: a single wide intraday window (e.g. 90d of 1H) times the server
+     * out — each request is capped to MAX_INTRADAY_SPAN_MS and the existing
+     * hasMoreAfter/nextAfter loop walks the remainder. Daily+ ranges are unaffected.
+     */
+    async fetchBarsInRange(symbol, timeframe, from, to, chartId, signal) {
+      const throwIfAborted = () => {
+        if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+      };
+      throwIfAborted();
+      const allBars = [];
+      const chunkSpan = isIntradayTimeframe(timeframe) ? MAX_INTRADAY_SPAN_MS : Number.POSITIVE_INFINITY;
+      const initParams = {
+        type: "init",
+        symbol,
+        timeframe,
+        from: from.valueOf(),
+        to: Math.min(to.valueOf(), from.valueOf() + chunkSpan),
+        limit: PAGE_LIMIT
+      };
+      let page = await this.client.getBarsPage(initParams);
+      const key = this.coverageKey(symbol, timeframe, chartId);
+      if (page.snapshotId) {
+        this.snapshotIds.set(key, page.snapshotId);
+      }
+      let bars = sortBarsByDate(pageToOHLCV(page.bars));
+      allBars.push(...bars);
+      while (page.hasMoreAfter && page.nextAfter !== null) {
+        throwIfAborted();
+        const forwardParams = {
+          type: "init",
+          symbol,
+          timeframe,
+          from: page.nextAfter,
+          to: Math.min(to.valueOf(), page.nextAfter + chunkSpan),
+          limit: PAGE_LIMIT
+        };
+        page = await this.client.getBarsPage(forwardParams);
+        if (page.snapshotId) {
+          this.snapshotIds.set(key, page.snapshotId);
+        }
+        bars = sortBarsByDate(pageToOHLCV(page.bars));
+        if (bars.length === 0) break;
+        allBars.push(...bars);
+      }
+      if (allBars.length === 0) {
+        this.lastRangeCoverageMap.set(key, [
+          { fromTs: from.valueOf(), toTs: to.valueOf(), status: "unresolved", reason: "source-no-data" }
+        ]);
+      } else {
+        const oldestTs = allBars[0].date.getTime();
+        const newestTs = allBars[allBars.length - 1].date.getTime();
+        const covered = { fromTs: oldestTs, toTs: newestTs, status: "covered" };
+        const fragments = [covered];
+        if (!page.hasMoreBefore) {
+          fragments.unshift({ fromTs: 0, toTs: oldestTs, status: "unresolved", reason: "boundary-exhausted" });
+        }
+        if (!page.hasMoreAfter) {
+          fragments.push({ fromTs: newestTs, toTs: to.valueOf(), status: "unresolved", reason: "boundary-exhausted" });
+        }
+        this.lastRangeCoverageMap.set(key, fragments);
+      }
+      return allBars;
+    }
+    /**
+     * Fetch bars before a given anchor date (backward pagination).
+     */
+    async fetchBarsBefore(symbol, timeframe, before, limit = PAGE_LIMIT, chartId) {
+      const key = this.coverageKey(symbol, timeframe, chartId);
+      const snapshotId = this.snapshotIds.get(key);
+      const params = {
+        type: "backward",
+        symbol,
+        timeframe,
+        before: before.valueOf(),
+        limit,
+        snapshotId
+      };
+      const page = await this.client.getBarsPage(params);
+      if (page.snapshotId) {
+        this.snapshotIds.set(key, page.snapshotId);
+      }
+      const bars = sortBarsByDate(pageToOHLCV(page.bars));
+      if (bars.length === 0) {
+        this.lastBackfillCoverageMap.set(key, [
+          { fromTs: 0, toTs: before.valueOf(), status: "unresolved", reason: "boundary-exhausted" }
+        ]);
+      } else {
+        const oldestTs = bars[0].date.getTime();
+        const newestTs = bars[bars.length - 1].date.getTime();
+        const covered = { fromTs: oldestTs, toTs: newestTs, status: "covered" };
+        if (!page.hasMoreBefore) {
+          this.lastBackfillCoverageMap.set(key, [
+            { fromTs: 0, toTs: oldestTs, status: "unresolved", reason: "boundary-exhausted" },
+            covered
+          ]);
+        } else {
+          this.lastBackfillCoverageMap.set(key, [covered]);
+        }
+      }
+      return bars;
+    }
+    /**
+     * Subscribe to real-time bar updates via WebSocket.
+     * Maps ticker_update events to OHLCVBar callbacks.
+     */
+    subscribeToBar(symbol, timeframe, onBar) {
+      const key = `${symbol.toUpperCase()}:${timeframe}`;
+      if (!this.wsClient) {
+        this.wsClient = new VNInvestWebSocketClient(
+          this.client.getPAT(),
+          this.client.getBase()
+        );
+        this.wsClient.setOnTickerUpdate(this.handleTickerUpdate.bind(this));
+        this.wsClient.connect();
+      }
+      if (!this.barSubscribers.has(key)) {
+        this.barSubscribers.set(key, /* @__PURE__ */ new Set());
+        this.wsClient.subscribe([symbol.toUpperCase()]);
+      }
+      this.barSubscribers.get(key).add(onBar);
+      return () => {
+        const subs = this.barSubscribers.get(key);
+        if (subs) {
+          subs.delete(onBar);
+          if (subs.size === 0) {
+            this.barSubscribers.delete(key);
+            this.wsClient?.unsubscribe([symbol.toUpperCase()]);
+          }
+        }
+      };
+    }
+    /** Not supported by VNInvest — returns no-op. */
+    subscribeToTrades(_symbol, _onTrade) {
+      return () => {
+      };
+    }
+    /** Not supported by VNInvest — returns no-op. */
+    subscribeToOrderbook(_symbol, _onUpdate) {
+      return () => {
+      };
+    }
+    /** Search symbols via GET /stocks/ endpoint. */
+    async searchSymbols(query) {
+      const items = await this.client.getStocks(query);
+      return items.map((item) => ({
+        symbol: item.symbol,
+        name: item.company_name,
+        exchange: item.exchange
+      }));
+    }
+    /** Clean up: destroy WebSocket connection. */
+    destroy() {
+      this.wsClient?.destroy();
+      this.wsClient = null;
+      this.barSubscribers.clear();
+    }
+    handleTickerUpdate(event) {
+      if (event.stale) return;
+      const price = Number.isFinite(event.price) ? event.price : event.current_price;
+      const currentPrice = Number.isFinite(event.current_price) ? event.current_price : price;
+      if (!Number.isFinite(currentPrice)) return;
+      const high = Number.isFinite(event.high_price) ? event.high_price : currentPrice;
+      const low = Number.isFinite(event.low_price) ? event.low_price : currentPrice;
+      const open = Number.isFinite(event.open_price) ? event.open_price : price;
+      const symbolUpper = event.symbol.toUpperCase();
+      const seq = Number.isFinite(event.seq) ? event.seq : 0;
+      const volume = Number.isFinite(event.volume) ? event.volume : 0;
+      for (const [key, subs] of this.barSubscribers.entries()) {
+        if (key.startsWith(`${symbolUpper}:`)) {
+          const bar = {
+            date: new Date(event.ts),
+            open,
+            high,
+            low,
+            close: currentPrice,
+            volume,
+            index: seq,
+            dataIndex: seq
+          };
+          for (const cb of subs) {
+            cb(bar);
+          }
+        }
+      }
+    }
+  };
+  var INTRADAY_TIMEFRAMES = /* @__PURE__ */ new Set(["1m", "5m", "15m", "1h", "2h", "4h"]);
+  var MAX_INTRADAY_SPAN_MS = 30 * 24 * 60 * 60 * 1e3;
+  function isIntradayTimeframe(timeframe) {
+    return INTRADAY_TIMEFRAMES.has(String(timeframe).toLowerCase());
+  }
+  function pageToOHLCV(bars) {
+    return bars.map((bar, index) => ({
+      date: bar.date,
+      open: bar.open,
+      high: bar.high,
+      low: bar.low,
+      close: bar.close,
+      volume: bar.volume,
+      index,
+      dataIndex: index
+    }));
+  }
+  function sortBarsByDate(bars) {
+    return bars.sort((a, b) => a.date.valueOf() - b.date.valueOf());
+  }
+  function useWatchlistRealtimeSync({
+    wsClient,
+    symbols,
+    onUpdate,
+    throttleMs = 500
+  }) {
+    const [tickerData, setTickerData] = react.useState(/* @__PURE__ */ new Map());
+    const bufferRef = react.useRef(/* @__PURE__ */ new Map());
+    const onUpdateRef = react.useRef(onUpdate);
+    onUpdateRef.current = onUpdate;
+    const subscribedSymbolsRef = react.useRef(/* @__PURE__ */ new Set());
+    react.useEffect(() => {
+      if (!wsClient || symbols.length === 0) return;
+      const ws = wsClient;
+      const uppercaseSymbols = symbols.map((s) => s.trim().toUpperCase()).filter(Boolean);
+      ws.subscribe(uppercaseSymbols);
+      for (const sym of uppercaseSymbols) {
+        subscribedSymbolsRef.current.add(sym);
+      }
+      const handleTickerUpdate = (event) => {
+        const sym = event.symbol.toUpperCase();
+        if (subscribedSymbolsRef.current.has(sym)) {
+          bufferRef.current.set(sym, event);
+        }
+      };
+      ws.setOnTickerUpdate(handleTickerUpdate);
+      const intervalId = setInterval(() => {
+        if (bufferRef.current.size === 0) return;
+        setTickerData((prev) => {
+          const next = new Map(prev);
+          bufferRef.current.forEach((value, key) => {
+            next.set(key, value);
+          });
+          onUpdateRef.current?.(next);
+          return next;
+        });
+        bufferRef.current.clear();
+      }, throttleMs);
+      return () => {
+        clearInterval(intervalId);
+        const activeSymbols = Array.from(subscribedSymbolsRef.current);
+        if (activeSymbols.length > 0) {
+          ws.unsubscribe(activeSymbols);
+        }
+        subscribedSymbolsRef.current.clear();
+        bufferRef.current.clear();
+      };
+    }, [wsClient, symbols, throttleMs]);
+    return tickerData;
+  }
+
+  // src/lib/adapters/ContinuousContractTypes.ts
+  var DEFAULT_VN_FUTURES_ROLL_CONFIG = {
+    "VN30F1M": {
+      rootSymbol: "VN30F",
+      rollMethod: "ratio",
+      rollTrigger: "days-before-expiry",
+      rollDaysBeforeExpiry: 3,
+      adjustVolumes: true
+    },
+    "VN30F1M-panama": {
+      rootSymbol: "VN30F",
+      rollMethod: "panama",
+      rollTrigger: "days-before-expiry",
+      rollDaysBeforeExpiry: 3,
+      adjustVolumes: true
+    },
+    "VN30F3M": {
+      rootSymbol: "VN30F",
+      rollMethod: "ratio",
+      rollTrigger: "days-before-expiry",
+      rollDaysBeforeExpiry: 5,
+      adjustVolumes: true
+    }
+  };
+
+  // src/lib/utils/logger.ts
+  var noop = () => {
+  };
+  var noopLogger = {
+    log: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    debug: noop,
+    trace: noop,
+    extend: () => noopLogger
+  };
+  function isDebugEnabled() {
+    if (typeof process !== "undefined" && process.env?.DEBUG) return true;
+    try {
+      if (typeof localStorage !== "undefined") {
+        return !!(localStorage.getItem("DEBUG") || localStorage.getItem("VNINVEST_DEBUG"));
+      }
+    } catch {
+    }
+    return false;
+  }
+  var enabled = isDebugEnabled();
+  function createLogFn(namespace, level) {
+    if (!enabled) return noop;
+    return (...args) => {
+      console[level](`[${namespace}]`, ...args);
+    };
+  }
+  function createLogger(namespace) {
+    if (!enabled) return noopLogger;
+    return {
+      log: createLogFn(namespace, "log"),
+      info: createLogFn(namespace, "info"),
+      warn: createLogFn(namespace, "warn"),
+      error: createLogFn(namespace, "error"),
+      debug: createLogFn(namespace, "debug"),
+      trace: createLogFn(namespace, "trace"),
+      extend: (sub) => createLogger(`${namespace}:${sub}`)
+    };
+  }
+  function createAdapterLogger(adapterName) {
+    return createLogger(`vninvestcharts-widget:adapter:${adapterName}`);
+  }
+
+  // src/lib/adapters/ContinuousContractAdapter.ts
+  var log = createAdapterLogger("continuous-contract");
+  var BFF_ENDPOINT = "/api/continuous-futures/stitch";
+  var metadataCache = /* @__PURE__ */ new Map();
+  var barsCache = /* @__PURE__ */ new Map();
+  var ContinuousContractAdapter = class {
+    name = "continuous-futures";
+    config;
+    rootSymbol;
+    fetchRawBars;
+    constructor(rootSymbol, config, fetchRawBars) {
+      this.rootSymbol = rootSymbol;
+      const defaultConfig = DEFAULT_VN_FUTURES_ROLL_CONFIG[rootSymbol] ?? DEFAULT_VN_FUTURES_ROLL_CONFIG["VN30F1M"];
+      this.config = { ...defaultConfig, ...config, rootSymbol };
+      this.fetchRawBars = fetchRawBars;
+    }
+    /** Get the continuous contract configuration */
+    getConfig() {
+      return { ...this.config };
+    }
+    /** Update roll configuration */
+    setConfig(config) {
+      this.config = { ...this.config, ...config };
+      metadataCache.delete(this.rootSymbol);
+    }
+    async getBars(params) {
+      const continuousParams = this.mapToContinuousParams(params);
+      const result = await this.fetchContinuousBars(continuousParams);
+      return {
+        bars: result.bars,
+        hasMore: result.hasMore
+      };
+    }
+    async getBarsCanonical(params) {
+      const continuousParams = this.mapToContinuousParams(params);
+      const result = await this.fetchContinuousBars(continuousParams);
+      const coverage = this.buildCoverage(result, continuousParams);
+      return {
+        bars: result.bars,
+        hasMore: result.hasMore,
+        coverage
+      };
+    }
+    async fetchBarsInRange(symbol, timeframe, from, to, signal) {
+      const params = {
+        rootSymbol: symbol,
+        interval: timeframe,
+        type: "init",
+        timestamp: null,
+        limit: Math.ceil((to.getTime() - from.getTime()) / this.intervalToMs(timeframe)) + 100,
+        signal
+      };
+      const result = await this.fetchContinuousBars(params);
+      return result.bars.filter(
+        (bar) => bar.timestamp >= from.getTime() && bar.timestamp <= to.getTime()
+      );
+    }
+    async fetchBarsBefore(symbol, timeframe, before, limit, signal) {
+      const params = {
+        rootSymbol: symbol,
+        interval: timeframe,
+        type: "backward",
+        timestamp: before.getTime(),
+        limit: limit ?? 500,
+        signal
+      };
+      const result = await this.fetchContinuousBars(params);
+      return result.bars;
+    }
+    getSourceSemantics() {
+      return {
+        sourceId: this.name,
+        sourceContractVersion: "continuous-futures-v1",
+        instrumentClass: "futures",
+        coverageMode: "window-hint",
+        sessionModel: "exchange-calendar",
+        timezone: "Asia/Ho_Chi_Minh",
+        sessionCalendarId: "vn-futures-calendar",
+        supportsExactRangeFetch: true,
+        supportsBackwardAnchor: true,
+        supportsForwardAnchor: false,
+        supportsLiveBars: true,
+        maxBarsPerRequest: 5e3,
+        finalityMode: "historically-correctable",
+        correctionLookbackMs: 7 * 24 * 60 * 60 * 1e3,
+        // 1 week
+        expectedGapReasons: [
+          "not-fetched",
+          "market-closed",
+          "source-no-data",
+          "rate-limited",
+          "boundary-exhausted",
+          "roll-gap"
+        ]
+      };
+    }
+    /**
+     * Fetch continuous contract bars - tries BFF first, falls back to local computation
+     */
+    async fetchContinuousBars(params) {
+      const cacheKey = this.getCacheKey(params);
+      const cached = barsCache.get(cacheKey);
+      if (cached && params.type !== "backward") {
+        const metadata = await this.getMetadata();
+        return {
+          bars: cached.slice(-params.limit),
+          hasMore: cached.length > params.limit,
+          metadata,
+          rollPointsInRange: []
+        };
+      }
+      try {
+        const bffResult = await this.fetchFromBFF(params);
+        if (bffResult) {
+          this.cacheBars(cacheKey, bffResult.bars);
+          return bffResult;
+        }
+      } catch (error) {
+        log.warn("[ContinuousContractAdapter] BFF fetch failed, falling back to local:", error);
+      }
+      return this.computeLocally(params);
+    }
+    /**
+     * Fetch from BFF endpoint
+     */
+    async fetchFromBFF(params) {
+      const metadata = await this.getMetadata();
+      const from = params.type === "backward" && params.timestamp ? params.timestamp - params.limit * this.intervalToMs(params.interval) : metadata.dataRange.from;
+      const to = params.type === "backward" && params.timestamp ? params.timestamp : metadata.dataRange.to;
+      const request = {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          rootSymbol: params.rootSymbol,
+          interval: params.interval,
+          from,
+          to,
+          rollConfig: this.config
+        }),
+        signal: params.signal
+      };
+      const response = await fetch(BFF_ENDPOINT, request);
+      if (!response.ok) {
+        throw new Error(`BFF error: ${response.status}`);
+      }
+      const data = await response.json();
+      return {
+        bars: data.bars,
+        hasMore: data.bars.length >= params.limit,
+        metadata: data.metadata,
+        rollPointsInRange: data.rollPoints
+      };
+    }
+    /**
+     * Local computation fallback - stitches contracts client-side
+     * Requires individual contract data to be available via another adapter
+     */
+    async computeLocally(params) {
+      const metadata = await this.getMetadata();
+      if (!this.fetchRawBars) {
+        log.warn("[ContinuousContractAdapter] fetchRawBars not provided, cannot compute locally");
+        return {
+          bars: [],
+          hasMore: false,
+          metadata,
+          rollPointsInRange: []
+        };
+      }
+      const fromMs = params.type === "backward" && params.timestamp ? params.timestamp - params.limit * this.intervalToMs(params.interval) : metadata.dataRange.from;
+      const toMs = params.type === "backward" && params.timestamp ? params.timestamp : metadata.dataRange.to;
+      const relevantContracts = metadata.contracts.filter(
+        (c) => c.lastTradeDate >= fromMs && c.firstTradeDate <= toMs
+      );
+      if (relevantContracts.length === 0) {
+        return {
+          bars: [],
+          hasMore: false,
+          metadata,
+          rollPointsInRange: []
+        };
+      }
+      const contractBars = /* @__PURE__ */ new Map();
+      await Promise.all(
+        relevantContracts.map(async (c) => {
+          try {
+            const bars = await this.fetchRawBars(c.symbol, params.interval, new Date(fromMs), new Date(toMs));
+            contractBars.set(c.symbol, [...bars]);
+          } catch (err) {
+            log.error(`Failed to fetch raw bars for contract ${c.symbol}:`, err);
+          }
+        })
+      );
+      const { computeRollAdjustment: computeRollAdjustment2 } = await Promise.resolve().then(() => (init_rollAlgorithms(), rollAlgorithms_exports));
+      const stitchResult = computeRollAdjustment2({
+        contracts: relevantContracts,
+        contractBars,
+        config: {
+          rollMethod: this.config.rollMethod,
+          adjustVolumes: this.config.adjustVolumes
+        },
+        from: fromMs,
+        to: toMs
+      });
+      return {
+        bars: stitchResult.bars,
+        hasMore: stitchResult.bars.length >= params.limit,
+        metadata: {
+          ...metadata,
+          totalCumulativeAdjustment: stitchResult.totalCumulativeAdjustment
+        },
+        rollPointsInRange: stitchResult.rollPoints
+      };
+    }
+    /**
+     * Get or fetch continuous contract metadata
+     */
+    async getMetadata() {
+      if (metadataCache.has(this.rootSymbol)) {
+        return metadataCache.get(this.rootSymbol);
+      }
+      try {
+        const response = await fetch(`${BFF_ENDPOINT}/metadata?rootSymbol=${this.rootSymbol}`);
+        if (response.ok) {
+          const metadata2 = await response.json();
+          metadataCache.set(this.rootSymbol, metadata2);
+          return metadata2;
+        }
+      } catch {
+      }
+      const metadata = this.generateSyntheticMetadata();
+      metadataCache.set(this.rootSymbol, metadata);
+      return metadata;
+    }
+    /**
+     * Generate synthetic metadata for development/testing
+     */
+    generateSyntheticMetadata() {
+      const now = Date.now();
+      const contracts = [
+        {
+          symbol: "VN30F2409",
+          rootSymbol: "VN30F",
+          expiry: (/* @__PURE__ */ new Date("2024-09-19")).getTime(),
+          firstTradeDate: (/* @__PURE__ */ new Date("2024-06-20")).getTime(),
+          lastTradeDate: (/* @__PURE__ */ new Date("2024-09-16")).getTime(),
+          monthCode: "U",
+          year: 24,
+          tickSize: 0.1,
+          multiplier: 1e5,
+          exchange: "VNX"
+        },
+        {
+          symbol: "VN30F2412",
+          rootSymbol: "VN30F",
+          expiry: (/* @__PURE__ */ new Date("2024-12-19")).getTime(),
+          firstTradeDate: (/* @__PURE__ */ new Date("2024-09-20")).getTime(),
+          lastTradeDate: (/* @__PURE__ */ new Date("2024-12-16")).getTime(),
+          monthCode: "Z",
+          year: 24,
+          tickSize: 0.1,
+          multiplier: 1e5,
+          exchange: "VNX"
+        },
+        {
+          symbol: "VN30F2503",
+          rootSymbol: "VN30F",
+          expiry: (/* @__PURE__ */ new Date("2025-03-20")).getTime(),
+          firstTradeDate: (/* @__PURE__ */ new Date("2024-12-20")).getTime(),
+          lastTradeDate: (/* @__PURE__ */ new Date("2025-03-17")).getTime(),
+          monthCode: "H",
+          year: 25,
+          tickSize: 0.1,
+          multiplier: 1e5,
+          exchange: "VNX"
+        }
+      ];
+      const rollPoints = [];
+      let cumulativeAdjustment = 0;
+      for (let i = 0; i < contracts.length - 1; i++) {
+        const fromContract = contracts[i];
+        const toContract = contracts[i + 1];
+        const rollDate = fromContract.lastTradeDate;
+        const fromPrice = 1200 + i * 10;
+        const toPrice = 1210 + i * 10;
+        let adjustmentFactor = 1;
+        const method = this.config.rollMethod;
+        if (method === "ratio") {
+          adjustmentFactor = fromPrice / toPrice;
+        } else if (method === "panama") {
+          adjustmentFactor = fromPrice - toPrice;
+          cumulativeAdjustment += adjustmentFactor;
+        } else if (method === "backward-ratio") {
+          adjustmentFactor = toPrice / fromPrice;
+        }
+        rollPoints.push({
+          timestamp: rollDate,
+          fromContract: fromContract.symbol,
+          toContract: toContract.symbol,
+          fromPrice,
+          toPrice,
+          adjustmentFactor,
+          cumulativeAdjustment,
+          method
+        });
+      }
+      return {
+        rootSymbol: this.rootSymbol,
+        contracts,
+        rollPoints,
+        activeContract: contracts[contracts.length - 1].symbol,
+        nextRollDate: contracts[contracts.length - 1].lastTradeDate,
+        totalCumulativeAdjustment: cumulativeAdjustment,
+        dataRange: {
+          from: contracts[0].firstTradeDate,
+          to: now
+        }
+      };
+    }
+    /**
+     * Build coverage fragments for canonical fetch
+     */
+    buildCoverage(result, params) {
+      const { bars, metadata } = result;
+      if (bars.length === 0) {
+        if (params.type === "backward" && params.timestamp !== null) {
+          return [
+            { fromTs: 0, toTs: params.timestamp, status: "unresolved", reason: "boundary-exhausted" }
+          ];
+        }
+        return [{ fromTs: 0, toTs: Date.now(), status: "unresolved", reason: "source-no-data" }];
+      }
+      const oldestTs = bars[0].timestamp;
+      const newestTs = bars[bars.length - 1].timestamp;
+      const covered = { fromTs: oldestTs, toTs: newestTs, status: "covered" };
+      const fragments = [covered];
+      if (oldestTs > metadata.dataRange.from) {
+        fragments.unshift({
+          fromTs: metadata.dataRange.from,
+          toTs: oldestTs,
+          status: "unresolved",
+          reason: "not-fetched"
+        });
+      }
+      if (!result.hasMore && newestTs < metadata.dataRange.to) {
+        fragments.push({
+          fromTs: newestTs,
+          toTs: metadata.dataRange.to,
+          status: "unresolved",
+          reason: "boundary-exhausted"
+        });
+      }
+      for (const rollPoint of result.rollPointsInRange) {
+        fragments.push({
+          fromTs: rollPoint.timestamp,
+          toTs: rollPoint.timestamp + 1,
+          status: "covered",
+          reason: "roll-gap"
+        });
+      }
+      return fragments.sort((a, b) => a.fromTs - b.fromTs);
+    }
+    mapToContinuousParams(params) {
+      return {
+        rootSymbol: params.symbol,
+        interval: params.interval,
+        type: params.type,
+        timestamp: params.timestamp,
+        limit: params.limit,
+        signal: params.signal
+      };
+    }
+    getCacheKey(params) {
+      return `${params.rootSymbol}|${params.interval}|${params.type}|${params.timestamp ?? "init"}|${params.limit}`;
+    }
+    cacheBars(key, bars) {
+      if (barsCache.size > 50) {
+        const firstKey = barsCache.keys().next().value;
+        if (firstKey) barsCache.delete(firstKey);
+      }
+      barsCache.set(key, bars);
+    }
+    intervalToMs(interval) {
+      switch (interval) {
+        case "1m":
+          return 6e4;
+        case "3m":
+          return 18e4;
+        case "5m":
+          return 3e5;
+        case "15m":
+          return 9e5;
+        case "30m":
+          return 18e5;
+        case "1h":
+        case "1H":
+          return 36e5;
+        case "2H":
+          return 72e5;
+        case "4h":
+        case "4H":
+          return 144e5;
+        case "D":
+        case "1D":
+        case "1d":
+          return 864e5;
+        case "W":
+        case "1W":
+        case "1w":
+          return 6048e5;
+        default:
+          return 864e5;
+      }
+    }
+  };
+
+  // src/widget/adapters/ContinuousFuturesStockDataAdapter.ts
+  var ContinuousFuturesStockDataAdapter = class {
+    continuousAdapter;
+    baseAdapter;
+    symbol;
+    constructor(symbol, baseAdapter) {
+      this.baseAdapter = baseAdapter;
+      this.symbol = symbol;
+      const config = DEFAULT_VN_FUTURES_ROLL_CONFIG[symbol] || DEFAULT_VN_FUTURES_ROLL_CONFIG["VN30F1M"];
+      this.continuousAdapter = new ContinuousContractAdapter(
+        config.rootSymbol,
+        config,
+        async (sym, tf, from, to) => {
+          const bars = await this.baseAdapter.fetchBarsInRange(sym, tf, from, to);
+          return bars.map((b) => ({
+            timestamp: b.date.getTime(),
+            open: b.open,
+            high: b.high,
+            low: b.low,
+            close: b.close,
+            volume: b.volume
+          }));
+        }
+      );
+    }
+    async fetchBarsInRange(symbol, timeframe, from, to, chartId) {
+      if (symbol === this.symbol) {
+        const rootSymbol = this.continuousAdapter.getConfig().rootSymbol;
+        const bars = await this.continuousAdapter.fetchBarsInRange?.(rootSymbol, timeframe, from, to);
+        return (bars || []).map((b, index) => ({
+          date: new Date(b.timestamp),
+          open: b.open,
+          high: b.high,
+          low: b.low,
+          close: b.close,
+          volume: b.volume,
+          index,
+          dataIndex: index
+        }));
+      }
+      return this.baseAdapter.fetchBarsInRange(symbol, timeframe, from, to, chartId);
+    }
+    async fetchBarsBefore(symbol, timeframe, before, limit, chartId) {
+      if (symbol === this.symbol) {
+        const rootSymbol = this.continuousAdapter.getConfig().rootSymbol;
+        const bars = await this.continuousAdapter.fetchBarsBefore?.(rootSymbol, timeframe, before, limit);
+        return (bars || []).map((b, index) => ({
+          date: new Date(b.timestamp),
+          open: b.open,
+          high: b.high,
+          low: b.low,
+          close: b.close,
+          volume: b.volume,
+          index,
+          dataIndex: index
+        }));
+      }
+      return this.baseAdapter.fetchBarsBefore(symbol, timeframe, before, limit, chartId);
+    }
+    subscribeToBar(symbol, timeframe, onBar) {
+      if (symbol === this.symbol) {
+        let unsubscribed = false;
+        let innerUnsubscribe = null;
+        this.continuousAdapter.getMetadata().then((metadata) => {
+          if (unsubscribed) return;
+          const activeContract = metadata.activeContract || symbol;
+          innerUnsubscribe = this.baseAdapter.subscribeToBar(activeContract, timeframe, onBar);
+        }).catch((err) => {
+          console.warn("Failed to resolve active contract for continuous subscription:", err);
+        });
+        return () => {
+          unsubscribed = true;
+          if (innerUnsubscribe) innerUnsubscribe();
+        };
+      }
+      return this.baseAdapter.subscribeToBar(symbol, timeframe, onBar);
+    }
+    subscribeToTrades(symbol, onTrade) {
+      return this.baseAdapter.subscribeToTrades(symbol, onTrade);
+    }
+    subscribeToOrderbook(symbol, onUpdate) {
+      return this.baseAdapter.subscribeToOrderbook(symbol, onUpdate);
+    }
+    async searchSymbols(query) {
+      return this.baseAdapter.searchSymbols(query);
+    }
+    getSourceSemantics() {
+      return this.continuousAdapter.getSourceSemantics();
+    }
+    getLastBackfillCoverage(symbol, timeframe, chartId) {
+      return this.baseAdapter.getLastBackfillCoverage?.(symbol, timeframe, chartId) ?? null;
+    }
+    getLastRangeCoverage(symbol, timeframe, chartId) {
+      return this.baseAdapter.getLastRangeCoverage?.(symbol, timeframe, chartId) ?? null;
+    }
+  };
+
+  // src/widget/adapters/MultiSourceDataAdapter.ts
+  function matchAdapter(symbol, config) {
+    const route = config.routes.find((r) => r.pattern.test(symbol));
+    return route?.adapter ?? config.defaultAdapter;
+  }
+  var MultiSourceDataAdapter = class {
+    constructor(config) {
+      this.config = config;
+      this._cache = /* @__PURE__ */ new Map();
+    }
+    config;
+    _cache;
+    _resolve(symbol) {
+      const cached = this._cache.get(symbol);
+      if (cached) {
+        return cached;
+      }
+      const adapter = matchAdapter(symbol, this.config);
+      this._cache.set(symbol, adapter);
+      return adapter;
+    }
+    async fetchBarsInRange(symbol, timeframe, from, to, chartId) {
+      return this._resolve(symbol).fetchBarsInRange(symbol, timeframe, from, to, chartId);
+    }
+    async fetchBarsBefore(symbol, timeframe, before, limit, chartId) {
+      return this._resolve(symbol).fetchBarsBefore(symbol, timeframe, before, limit, chartId);
+    }
+    subscribeToBar(symbol, timeframe, onBar) {
+      return this._resolve(symbol).subscribeToBar(symbol, timeframe, onBar);
+    }
+    subscribeToTrades(symbol, onTrade) {
+      return this._resolve(symbol).subscribeToTrades(symbol, onTrade);
+    }
+    subscribeToOrderbook(symbol, onUpdate) {
+      return this._resolve(symbol).subscribeToOrderbook(symbol, onUpdate);
+    }
+    async searchSymbols(query) {
+      const adapters = [
+        ...this.config.routes.map((r) => r.adapter),
+        this.config.defaultAdapter
+      ];
+      const results = await Promise.all(
+        adapters.map((a) => a.searchSymbols(query))
+      );
+      const flat = results.flat();
+      const seen = /* @__PURE__ */ new Set();
+      return flat.filter((s) => {
+        if (seen.has(s.symbol)) return false;
+        seen.add(s.symbol);
+        return true;
+      });
+    }
+    getLastBackfillCoverage(symbol, timeframe, chartId) {
+      if (!symbol) return null;
+      return this._resolve(symbol).getLastBackfillCoverage?.(symbol, timeframe, chartId) ?? null;
+    }
+    getLastRangeCoverage(symbol, timeframe, chartId) {
+      if (!symbol) return null;
+      return this._resolve(symbol).getLastRangeCoverage?.(symbol, timeframe, chartId) ?? null;
+    }
+  };
+
+  exports.ContinuousFuturesStockDataAdapter = ContinuousFuturesStockDataAdapter;
+  exports.MultiSourceDataAdapter = MultiSourceDataAdapter;
+  exports.TIMEFRAME_MAP = TIMEFRAME_MAP;
+  exports.VNInvestClient = VNInvestClient;
+  exports.VNInvestDataAdapter = VNInvestDataAdapter;
+  exports.VNInvestWebSocketClient = VNInvestWebSocketClient;
+  exports.buildBackwardPageRequest = buildBackwardPageRequest;
+  exports.normalizeBarsPagingMeta = normalizeBarsPagingMeta;
+  exports.resolveApiBase = resolveApiBase;
+  exports.useWatchlistRealtimeSync = useWatchlistRealtimeSync;
+
+}));