fix(quote): keep pre-market/after-hours apart from the regular-session price

Outside regular hours Nasdaq's primaryData is the extended-hours trade, with
its change measured from the 16:00 close; it was shown as the day's price and
change (SPY after hours: -0.62% shown, the day was -0.37%). splitSessions()
now uses the closed secondaryData as the regular price and returns the
extended trade separately as quote.extended (Yahoo: pre/postMarket* fields).
previousClose is derived from price - change, which matches the change shown.

Also adds ext=1 on 1D history: 4:00-20:00 ET five-minute candles, with
pre/post candles tagged via candle.session. Only the literal '1' on 1D enables
it, so the cache key space stays bounded.

Author: niravpatidar37

server/src/providers/nasdaq.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { minutePointsToCandles } from "./nasdaq.js";
+import { minutePointsToCandles, splitSessions } from "./nasdaq.js";
+import { yahooExtended } from "./yahoo.js";
 
 // Nasdaq encodes ET wall-clock time as if it were UTC (see nasdaq.ts).
 const at = (hhmm: string, y: number, w = 100) => ({ x: Date.parse(`2026-10-14T${hhmm}:00Z`), y, w });
@@ -29,3 +30,82 @@ describe("minutePointsToCandles", () => {
     expect(candles[0].close).toBe(7);
   });
 });
+
+// Nasdaq encodes ET wall-clock time as if it were UTC.
+const etAt = (hhmm: string) => Date.parse(`2026-10-29T${hhmm}:00Z`);
+
+describe("minutePointsToCandles extended hours", () => {
+  const pts = [
+    { x: etAt("04:00"), y: 770, w: 10 },
+    { x: etAt("09:29"), y: 771, w: 10 },
+    { x: etAt("09:30"), y: 772, w: 10 },
+    { x: etAt("15:59"), y: 769.49, w: 10 },
+    { x: etAt("16:00"), y: 769.3, w: 10 },
+    { x: etAt("19:59"), y: 764.74, w: 10 },
+    { x: etAt("20:00"), y: 1, w: 10 },
+    { x: etAt("03:59"), y: 1, w: 10 },
+  ];
+
+  it("regular mode keeps 9:30-16:00 only, with no session tags", () => {
+    const c = minutePointsToCandles(pts);
+    expect(c.map((x) => x.close)).toEqual([772, 769.49]);
+    expect(c.every((x) => x.session === undefined)).toBe(true);
+  });
+
+  it("extended mode keeps 4:00-20:00 and tags pre/post candles", () => {
+    const c = minutePointsToCandles(pts, 5, true);
+    expect(c.map((x) => [x.close, x.session ?? "regular"])).toEqual([
+      [770, "pre"], [771, "pre"], [772, "regular"], [769.49, "regular"], [769.3, "post"], [764.74, "post"],
+    ]);
+  });
+});
+
+describe("splitSessions", () => {
+  // Shape captured from Nasdaq /info for SPY at 19:56 ET on Oct 29, 2026.
+  const afterHours = {
+    marketStatus: "After-Hours",
+    primaryData: { lastSalePrice: "$764.744", netChange: "-4.746", percentageChange: "-0.62%", lastTradeTimestamp: "Oct 29, 2026 7:56 PM ET" },
+    secondaryData: { lastSalePrice: "$769.49", netChange: "-2.82", percentageChange: "-0.37%", lastTradeTimestamp: "Closed at Oct 29, 2026 4:00 PM ET" },
+  };
+
+  it("after hours: the regular close is the price, the after-hours trade is separate", () => {
+    const { regular, extended } = splitSessions(afterHours);
+    expect(regular).toEqual({ price: 769.49, change: -2.82, changePercent: -0.37 });
+    expect(extended).toEqual({ session: "post", price: 764.744, change: -4.746, changePercent: -0.62, time: "7:56 PM ET" });
+  });
+
+  it("pre-market is labelled pre", () => {
+    const pre = { ...afterHours, marketStatus: "Pre-Market", primaryData: { ...afterHours.primaryData, lastTradeTimestamp: "Oct 30, 2026 8:05 AM ET" } };
+    expect(splitSessions(pre).extended).toMatchObject({ session: "pre", time: "8:05 AM ET" });
+  });
+
+  it("regular hours (no closed secondary): primary is the price, no extended", () => {
+    const open = { marketStatus: "Market Open", primaryData: afterHours.primaryData, secondaryData: null };
+    expect(splitSessions(open)).toEqual({ regular: { price: 764.744, change: -4.746, changePercent: -0.62 }, extended: null });
+  });
+
+  it("an empty secondary price is not mistaken for a $0 close", () => {
+    const blank = { ...afterHours, secondaryData: { ...afterHours.secondaryData, lastSalePrice: "" } };
+    expect(splitSessions(blank).extended).toBeNull();
+    expect(splitSessions(blank).regular.price).toBe(764.744);
+  });
+
+  it("ignores junk input", () => {
+    expect(splitSessions(null)).toEqual({ regular: { price: null, change: null, changePercent: null }, extended: null });
+    expect(splitSessions({ primaryData: { percentageChange: "abc%" } }).regular.changePercent).toBeNull();
+  });
+});
+
+describe("yahooExtended", () => {
+  const base = { regularMarketPrice: 769.49, postMarketPrice: 764.74, postMarketChange: -4.75, postMarketChangePercent: -0.617, postMarketTime: 1793318160 };
+  it("post / closed states use postMarket fields", () => {
+    expect(yahooExtended({ ...base, marketState: "POST" })).toMatchObject({ session: "post", price: 764.74, change: -4.75 });
+    expect(yahooExtended({ ...base, marketState: "CLOSED" })?.session).toBe("post");
+    expect(yahooExtended({ ...base, marketState: "POST" })?.time).toMatch(/^\d{1,2}:\d{2} [AP]M ET$/);
+  });
+  it("regular hours or missing price gives nothing", () => {
+    expect(yahooExtended({ ...base, marketState: "REGULAR" })).toBeNull();
+    expect(yahooExtended({ marketState: "PRE", preMarketPrice: 0 })).toBeNull();
+    expect(yahooExtended({ marketState: "PRE", preMarketPrice: 771.2 })).toMatchObject({ session: "pre", price: 771.2, time: null });
+  });
+});

server/src/providers/nasdaq.ts

@@ -1,4 +1,4 @@
-import type { Quote, Candle } from "./yahoo.js";
+import type { Quote, Candle, ExtendedQuote } from "./yahoo.js";
 import { httpFetch } from "../http.js";
 
 const UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36";
@@ -78,12 +78,16 @@ export async function quote(symbol: string): Promise<Quote> {
     nfetch(`https://api.nasdaq.com/api/quote/${encodeURIComponent(symbol)}/summary?assetclass=${assetclass}`).catch(() => null),
   ]);
 
-  const price = money(info.primaryData?.lastSalePrice);
-  const prevClose = money(info.primaryData?.previousClose) ?? money(summary?.summaryData?.PreviousClose?.value);
-  const change = money(info.primaryData?.netChange);
-  const pctChange = typeof info.primaryData?.percentageChange === "string"
-    ? Number(info.primaryData.percentageChange.replace(/[%+]/g, ""))
-    : null;
+  const { regular, extended } = splitSessions(info);
+  const price = regular.price;
+  const change = regular.change;
+  const pctChange = regular.changePercent;
+  // price - change is the close the change was measured against; Nasdaq's summary
+  // "PreviousClose" sometimes disagrees with it (seen off by $2.65 on SPY after hours).
+  const prevClose =
+    price !== null && change !== null
+      ? Math.round((price - change) * 10_000) / 10_000
+      : money(info.primaryData?.previousClose) ?? money(summary?.summaryData?.PreviousClose?.value);
 
   const [dayLow, dayHigh] = (info.keyStats?.dayrange?.value ?? "").split(" - ").map((s: string) => money(s));
   const [wLow, wHigh] = (info.keyStats?.fiftyTwoWeekHighLow?.value ?? "").split(" - ").map((s: string) => money(s));
@@ -97,7 +101,7 @@ export async function quote(symbol: string): Promise<Quote> {
     name: info.companyName ?? null,
     price,
     change,
-    changePercent: isFinite(pctChange as number) ? pctChange : null,
+    changePercent: pctChange,
     open: null,
     high: dayHigh ?? null,
     low: dayLow ?? null,
@@ -119,6 +123,40 @@ export async function quote(symbol: string): Promise<Quote> {
     marketState: info.marketStatus ?? null,
     time: null,
     source: "nasdaq",
+    extended,
+  };
+}
+
+const pct = (v: unknown): number | null => {
+  if (typeof v !== "string") return null;
+  const n = Number(v.replace(/[%+,]/g, ""));
+  return Number.isFinite(n) ? n : null;
+};
+
+/**
+ * Outside regular hours Nasdaq's `primaryData` is the pre-market/after-hours
+ * trade (change measured from the last regular close) and `secondaryData` is
+ * that regular close ("Closed at Oct 29, 2026 4:00 PM ET"). Showing primaryData
+ * as the day's price mislabelled an after-hours move as the day's change.
+ */
+export function splitSessions(info: any): {
+  regular: { price: number | null; change: number | null; changePercent: number | null };
+  extended: ExtendedQuote | null;
+} {
+  const p = info?.primaryData ?? {};
+  const s = info?.secondaryData;
+  const read = (d: any) => ({ price: money(d?.lastSalePrice), change: money(d?.netChange), changePercent: pct(d?.percentageChange) });
+  const closed = s && /closed/i.test(String(s.lastTradeTimestamp ?? "")) && (money(s.lastSalePrice) ?? 0) > 0;
+  if (!closed) return { regular: read(p), extended: null };
+  const ext = read(p);
+  const status = String(info?.marketStatus ?? "").toLowerCase();
+  const clock = /(\d{1,2}:\d{2} [AP]M) ET/.exec(String(p.lastTradeTimestamp ?? ""));
+  return {
+    regular: read(s),
+    extended:
+      ext.price !== null && ext.price > 0
+        ? { session: status.includes("pre") ? "pre" : "post", ...ext, price: ext.price, time: clock ? `${clock[1]} ET` : null }
+        : null,
   };
 }
 
@@ -155,21 +193,30 @@ export async function history(symbol: string, rangeKey: string): Promise<Candle[
 /** Regular US session, in minutes after midnight ET. */
 const SESSION_OPEN_MIN = 9 * 60 + 30;
 const SESSION_CLOSE_MIN = 16 * 60;
+/** Extended hours: pre-market from 4:00, after-hours until 20:00 ET. */
+const EXT_OPEN_MIN = 4 * 60;
+const EXT_CLOSE_MIN = 20 * 60;
 
 /**
  * Folds Nasdaq's per-minute intraday points into OHLC candles of `bucketMin`
  * minutes, regular session only. Nasdaq encodes ET wall-clock time in `x` as
  * if it were UTC (an 11:39 AM ET point has x = 11:39Z), the same convention
  * its daily chart uses, so UTC getters yield the ET session time.
  */
-export function minutePointsToCandles(points: Array<{ x: number; y: number; w?: number }>, bucketMin = 5): Candle[] {
+export function minutePointsToCandles(
+  points: Array<{ x: number; y: number; w?: number }>,
+  bucketMin = 5,
+  extended = false
+): Candle[] {
   const bucketSec = bucketMin * 60;
   const candles: Candle[] = [];
+  const [from, to] = extended ? [EXT_OPEN_MIN, EXT_CLOSE_MIN] : [SESSION_OPEN_MIN, SESSION_CLOSE_MIN];
   for (const p of points) {
     if (!Number.isFinite(p?.x) || !Number.isFinite(p?.y)) continue;
     const d = new Date(p.x);
     const minuteOfDay = d.getUTCHours() * 60 + d.getUTCMinutes();
-    if (minuteOfDay < SESSION_OPEN_MIN || minuteOfDay >= SESSION_CLOSE_MIN) continue;
+    if (minuteOfDay < from || minuteOfDay >= to) continue;
+    const session = minuteOfDay < SESSION_OPEN_MIN ? "pre" : minuteOfDay >= SESSION_CLOSE_MIN ? "post" : undefined;
     const time = Math.floor(p.x / 1000 / bucketSec) * bucketSec;
     const volume = Number.isFinite(p.w) ? Math.round(p.w as number) : 0;
     const last = candles[candles.length - 1];
@@ -179,7 +226,7 @@ export function minutePointsToCandles(points: Array<{ x: number; y: number; w?:
       last.close = p.y;
       last.volume += volume;
     } else {
-      candles.push({ time, open: p.y, high: p.y, low: p.y, close: p.y, volume });
+      candles.push({ time, open: p.y, high: p.y, low: p.y, close: p.y, volume, ...(session ? { session } : {}) });
     }
   }
   return candles;
@@ -190,12 +237,12 @@ export function minutePointsToCandles(points: Array<{ x: number; y: number; w?:
  * when there's nothing in-session yet (pre-market, holidays) so callers fall
  * back to the daily chart instead of rendering an empty one.
  */
-export async function intraday(symbol: string, bucketMin = 5): Promise<Candle[]> {
+export async function intraday(symbol: string, bucketMin = 5, extended = false): Promise<Candle[]> {
   const assetclass = await resolveAssetClass(symbol);
   const data = await nfetch(
     `https://api.nasdaq.com/api/quote/${encodeURIComponent(symbol)}/chart?assetclass=${assetclass}&charttype=rs`
   );
-  const candles = minutePointsToCandles(data.chart ?? [], bucketMin);
+  const candles = minutePointsToCandles(data.chart ?? [], bucketMin, extended);
   if (candles.length === 0) throw new Error(`nasdaq: no in-session intraday data for ${symbol}`);
   return candles;
 }

server/src/providers/yahoo.ts

@@ -50,9 +50,22 @@ export type Quote = {
   marketState: string | null;
   time: number | null;
   source: string;
+  /** Pre-market / after-hours trading, kept apart from the regular-session price above. */
+  extended?: ExtendedQuote | null;
 };
 
-export type Candle = { time: number; open: number; high: number; low: number; close: number; volume: number };
+export type ExtendedQuote = {
+  session: "pre" | "post";
+  price: number;
+  /** Versus the reference the provider uses: the latest regular-session close. */
+  change: number | null;
+  changePercent: number | null;
+  /** Wall-clock label such as "7:56 PM ET", or null. */
+  time: string | null;
+};
+
+/** `session` is set only on extended-hours candles (1D with ext=1). */
+export type Candle = { time: number; open: number; high: number; low: number; close: number; volume: number; session?: "pre" | "post" };
 
 // ---- crumb/cookie session (needed for the v7 quote and options endpoints) ----
 
@@ -174,9 +187,28 @@ export async function quotes(symbols: string[]): Promise<Quote[]> {
     marketState: r.marketState ?? null,
     time: n(r.regularMarketTime),
     source: "yahoo",
+    extended: yahooExtended(r),
   }));
 }
 
+const etClock = (unixSec: number | null): string | null =>
+  unixSec === null
+    ? null
+    : new Date(unixSec * 1000).toLocaleTimeString("en-US", { timeZone: "America/New_York", hour: "numeric", minute: "2-digit" }) + " ET";
+
+/** Yahoo reports extended hours in separate pre/postMarket* fields; marketState says which applies now. */
+export function yahooExtended(r: any): ExtendedQuote | null {
+  const state = String(r?.marketState ?? "").toUpperCase();
+  const pick = (session: "pre" | "post", key: "preMarket" | "postMarket"): ExtendedQuote | null => {
+    const price = n(r?.[`${key}Price`]);
+    if (price === null || price <= 0) return null;
+    return { session, price, change: n(r[`${key}Change`]), changePercent: n(r[`${key}ChangePercent`]), time: etClock(n(r[`${key}Time`])) };
+  };
+  if (state.startsWith("PRE")) return pick("pre", "preMarket");
+  if (state.startsWith("POST") || state === "CLOSED") return pick("post", "postMarket");
+  return null;
+}
+
 /** Quote fallback that works without crumb, using the chart endpoint's metadata. */
 export async function quoteFromChart(symbol: string): Promise<Quote> {
   const json = await yfetch(

server/src/routes/market.ts

@@ -255,10 +255,13 @@ marketRouter.get("/history/:symbol", async (req, res) => {
   // Allowlisted: every distinct string was a distinct cache key, so arbitrary
   // values bypassed the cache and forced a fresh upstream fan-out each time.
   if (!HISTORY_RANGES.has(rangeKey)) return res.status(400).json({ error: "unsupported range" });
+  // Extended hours (4:00-20:00 ET) only exist for the 1D intraday view. Only the
+  // literal "1" enables it, so the cache key space stays two values per symbol.
+  const ext = rangeKey === "1D" && req.query.ext === "1";
   try {
     // 1D is the live view (the chart polls it every 8s), so it gets a short TTL.
     const ttl = rangeKey === "1D" ? INTRADAY_TTL : HISTORY_TTL;
-    const data = await cached(`history:${symbol}:${rangeKey}`, ttl, () =>
+    const data = await cached(`history:${symbol}:${rangeKey}${ext ? ":ext" : ""}`, ttl, () =>
       binance.CRYPTO_SYMBOLS.has(symbol)
         ? binance.history(symbol, rangeKey)
         : isVix(symbol)
@@ -268,7 +271,7 @@ marketRouter.get("/history/:symbol", async (req, res) => {
             // daily chart answered first, so "1D" showed a few daily bars with
             // no candle for the session in progress.
             ...(rangeKey === "1D"
-              ? ([["nasdaq-intraday", () => nasdaq.intraday(symbol)]] as Array<[string, () => Promise<yahoo.Candle[]>]>)
+              ? ([["nasdaq-intraday", () => nasdaq.intraday(symbol, 5, ext)]] as Array<[string, () => Promise<yahoo.Candle[]>]>)
               : []),
             ["nasdaq", () => nasdaq.history(symbol, rangeKey)],
             ["yahoo", () => yahoo.history(symbol, yahooRange(rangeKey).range, yahooRange(rangeKey).interval)],