gloomberb 0.8.2 → 0.9.0

package/src/plugins/builtin/portfolio-list/pane/supplemental.ts

@@ -0,0 +1,281 @@
+import { useEffect, useMemo, useRef, useState, type Dispatch, type SetStateAction } from "react";
+import type { ColumnConfig } from "../../../../types/config";
+import type { AnalystResearchData, CorporateActionsData } from "../../../../types/financials";
+import type { DataProvider, EarningsEvent } from "../../../../types/data-provider";
+import type { TickerRecord } from "../../../../types/ticker";
+import { useAssetData } from "../../../runtime";
+import { loadEarningsCalendar } from "../../earnings/data/cache";
+
+const SUPPLEMENTAL_BATCH_LIMIT = 6;
+const ANALYST_COLUMN_IDS = new Set(["target", "target_pct", "rating"]);
+const CORPORATE_COLUMN_IDS = new Set(["ex_div", "next_earn"]);
+const EARNINGS_COLUMN_IDS = new Set(["next_earn"]);
+
+interface SupplementalTarget {
+  symbol: string;
+  exchange: string;
+}
+
+export interface PortfolioSupplementalData {
+  analystResearch: Map<string, AnalystResearchData | null>;
+  corporateActions: Map<string, CorporateActionsData | null>;
+  earningsEvents: Map<string, EarningsEvent | null>;
+  version: number;
+}
+
+type SupplementalState = PortfolioSupplementalData;
+
+function targetKey(targets: SupplementalTarget[]): string {
+  return targets.map((target) => `${target.symbol}:${target.exchange}`).join("|");
+}
+
+function targetsFromTickers(tickers: TickerRecord[]): SupplementalTarget[] {
+  return tickers.map((ticker) => ({
+    symbol: ticker.metadata.ticker,
+    exchange: ticker.metadata.exchange ?? "",
+  }));
+}
+
+function needsAnyColumn(columns: ColumnConfig[], ids: Set<string>): boolean {
+  return columns.some((column) => ids.has(column.id));
+}
+
+function pickMissingBatch<T>(
+  targets: SupplementalTarget[],
+  values: Map<string, T | null>,
+  inFlight: Set<string>,
+): SupplementalTarget[] {
+  const batch: SupplementalTarget[] = [];
+  for (const target of targets) {
+    if (values.has(target.symbol) || inFlight.has(target.symbol)) continue;
+    batch.push(target);
+    if (batch.length >= SUPPLEMENTAL_BATCH_LIMIT) break;
+  }
+  return batch;
+}
+
+function markMissing<T>(
+  targets: SupplementalTarget[],
+  values: Map<string, T | null>,
+): Map<string, T | null> | null {
+  let changed = false;
+  const next = new Map(values);
+  for (const target of targets) {
+    if (next.has(target.symbol)) continue;
+    next.set(target.symbol, null);
+    changed = true;
+  }
+  return changed ? next : null;
+}
+
+function setAnalystValues(
+  current: SupplementalState,
+  entries: Array<readonly [string, AnalystResearchData | null]>,
+): SupplementalState {
+  const analystResearch = new Map(current.analystResearch);
+  for (const [symbol, data] of entries) {
+    analystResearch.set(symbol, data);
+  }
+  return { ...current, analystResearch, version: current.version + 1 };
+}
+
+function setCorporateValues(
+  current: SupplementalState,
+  entries: Array<readonly [string, CorporateActionsData | null]>,
+): SupplementalState {
+  const corporateActions = new Map(current.corporateActions);
+  for (const [symbol, data] of entries) {
+    corporateActions.set(symbol, data);
+  }
+  return { ...current, corporateActions, version: current.version + 1 };
+}
+
+function setEarningsValues(
+  current: SupplementalState,
+  symbols: string[],
+  events: EarningsEvent[],
+): SupplementalState {
+  const eventsBySymbol = new Map<string, EarningsEvent>();
+  const now = Date.now();
+  for (const event of events) {
+    const symbol = event.symbol.trim().toUpperCase();
+    if (!symbol || event.earningsDate.getTime() < now) continue;
+    const currentEvent = eventsBySymbol.get(symbol);
+    if (!currentEvent || event.earningsDate < currentEvent.earningsDate) {
+      eventsBySymbol.set(symbol, event);
+    }
+  }
+
+  const earningsEvents = new Map(current.earningsEvents);
+  for (const symbol of symbols) {
+    earningsEvents.set(symbol, eventsBySymbol.get(symbol) ?? null);
+  }
+  return { ...current, earningsEvents, version: current.version + 1 };
+}
+
+function useAnalystSupplemental(
+  provider: DataProvider | null | undefined,
+  targets: SupplementalTarget[],
+  enabled: boolean,
+  state: SupplementalState,
+  setState: Dispatch<SetStateAction<SupplementalState>>,
+) {
+  const inFlightRef = useRef(new Set<string>());
+  const targetsKey = targetKey(targets);
+
+  useEffect(() => {
+    if (!enabled || targets.length === 0) return;
+    if (!provider?.getAnalystResearch) {
+      setState((current) => {
+        const missing = markMissing(targets, current.analystResearch);
+        return missing ? { ...current, analystResearch: missing, version: current.version + 1 } : current;
+      });
+      return;
+    }
+
+    const batch = pickMissingBatch(targets, state.analystResearch, inFlightRef.current);
+    if (batch.length === 0) return;
+    for (const target of batch) inFlightRef.current.add(target.symbol);
+
+    let cancelled = false;
+    Promise.all(batch.map(async (target) => {
+      try {
+        const data = await provider.getAnalystResearch!(target.symbol, target.exchange);
+        return [target.symbol, data] as const;
+      } catch {
+        return [target.symbol, null] as const;
+      } finally {
+        inFlightRef.current.delete(target.symbol);
+      }
+    })).then((entries) => {
+      if (cancelled) return;
+      setState((current) => setAnalystValues(current, entries));
+    }).catch(() => {});
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, setState, state.analystResearch, targetsKey]);
+}
+
+function useCorporateSupplemental(
+  provider: DataProvider | null | undefined,
+  targets: SupplementalTarget[],
+  enabled: boolean,
+  state: SupplementalState,
+  setState: Dispatch<SetStateAction<SupplementalState>>,
+) {
+  const inFlightRef = useRef(new Set<string>());
+  const targetsKey = targetKey(targets);
+
+  useEffect(() => {
+    if (!enabled || targets.length === 0) return;
+    if (!provider?.getCorporateActions) {
+      setState((current) => {
+        const missing = markMissing(targets, current.corporateActions);
+        return missing ? { ...current, corporateActions: missing, version: current.version + 1 } : current;
+      });
+      return;
+    }
+
+    const batch = pickMissingBatch(targets, state.corporateActions, inFlightRef.current);
+    if (batch.length === 0) return;
+    for (const target of batch) inFlightRef.current.add(target.symbol);
+
+    let cancelled = false;
+    Promise.all(batch.map(async (target) => {
+      try {
+        const data = await provider.getCorporateActions!(target.symbol, target.exchange);
+        return [target.symbol, data] as const;
+      } catch {
+        return [target.symbol, null] as const;
+      } finally {
+        inFlightRef.current.delete(target.symbol);
+      }
+    })).then((entries) => {
+      if (cancelled) return;
+      setState((current) => setCorporateValues(current, entries));
+    }).catch(() => {});
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, setState, state.corporateActions, targetsKey]);
+}
+
+function useEarningsSupplemental(
+  provider: DataProvider | null | undefined,
+  targets: SupplementalTarget[],
+  enabled: boolean,
+  state: SupplementalState,
+  setState: Dispatch<SetStateAction<SupplementalState>>,
+) {
+  const inFlightRef = useRef(false);
+  const targetsKey = targetKey(targets);
+
+  useEffect(() => {
+    if (!enabled || targets.length === 0) return;
+    if (!provider?.getEarningsCalendar) {
+      setState((current) => {
+        const missing = markMissing(targets, current.earningsEvents);
+        return missing ? { ...current, earningsEvents: missing, version: current.version + 1 } : current;
+      });
+      return;
+    }
+
+    const missingSymbols = targets
+      .map((target) => target.symbol)
+      .filter((symbol) => !state.earningsEvents.has(symbol));
+    if (missingSymbols.length === 0 || inFlightRef.current) return;
+
+    inFlightRef.current = true;
+    let cancelled = false;
+    loadEarningsCalendar(provider, missingSymbols)
+      .then((events) => {
+        if (cancelled) return;
+        setState((current) => setEarningsValues(current, missingSymbols, events));
+      })
+      .catch(() => {
+        if (cancelled) return;
+        setState((current) => ({
+          ...current,
+          earningsEvents: markMissing(
+            missingSymbols.map((symbol) => ({ symbol, exchange: "" })),
+            current.earningsEvents,
+          ) ?? current.earningsEvents,
+          version: current.version + 1,
+        }));
+      })
+      .finally(() => {
+        inFlightRef.current = false;
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, setState, state.earningsEvents, targetsKey]);
+}
+
+export function usePortfolioSupplementalData(
+  tickers: TickerRecord[],
+  columns: ColumnConfig[],
+  appActive: boolean,
+): PortfolioSupplementalData {
+  const provider = useAssetData();
+  const targets = useMemo(() => targetsFromTickers(tickers), [tickers]);
+  const [state, setState] = useState<SupplementalState>(() => ({
+    analystResearch: new Map(),
+    corporateActions: new Map(),
+    earningsEvents: new Map(),
+    version: 0,
+  }));
+  const needsAnalyst = appActive && needsAnyColumn(columns, ANALYST_COLUMN_IDS);
+  const needsCorporate = appActive && needsAnyColumn(columns, CORPORATE_COLUMN_IDS);
+  const needsEarnings = appActive && needsAnyColumn(columns, EARNINGS_COLUMN_IDS);
+
+  useAnalystSupplemental(provider, targets, needsAnalyst, state, setState);
+  useCorporateSupplemental(provider, targets, needsCorporate, state, setState);
+  useEarningsSupplemental(provider, targets, needsEarnings, state, setState);
+
+  return state;
+}

package/src/plugins/builtin/portfolio-list/settings.ts

@@ -21,30 +21,57 @@ export interface CollectionEntry {
 const PORTFOLIO_COLUMN_DEFS: ColumnConfig[] = [
   ...DEFAULT_COLUMNS,
   { id: PRICE_SPARKLINE_COLUMN_ID, label: PRICE_SPARKLINE_PERIOD_LABEL, width: 6, align: "left" },
+  { id: "name", label: "NAME", width: 16, align: "left" },
+  { id: "asset_type", label: "TYPE", width: 5, align: "left" },
+  { id: "exchange", label: "EXCH", width: 8, align: "left" },
+  { id: "currency", label: "CCY", width: 4, align: "left" },
+  { id: "sector", label: "SECTOR", width: 14, align: "left" },
+  { id: "industry", label: "INDUSTRY", width: 16, align: "left" },
+  { id: "tags", label: "TAGS", width: 14, align: "left" },
+  { id: "volume", label: "VOL", width: 8, align: "right", format: "compact" },
+  { id: "dollar_volume", label: "$VOL", width: 9, align: "right", format: "compact" },
+  { id: "range_52w", label: "52W%", width: 7, align: "right", format: "percent" },
   { id: "bid", label: "BID", width: 10, align: "right", format: "currency" },
   { id: "ask", label: "ASK", width: 10, align: "right", format: "currency" },
   { id: "spread", label: "SPREAD", width: 10, align: "right", format: "currency" },
+  { id: "spread_pct", label: "SPR%", width: 7, align: "right", format: "percent" },
+  { id: "bid_ask_size", label: "B/A SZ", width: 9, align: "right", format: "compact" },
   { id: "change", label: "CHG", width: 9, align: "right", format: "currency" },
   { id: "ext_hours", label: "EXT%", width: 8, align: "right", format: "percent" },
   { id: "dividend_yield", label: "DIV%", width: 7, align: "right", format: "percent" },
+  { id: "target", label: "TARGET", width: 10, align: "right", format: "currency" },
+  { id: "target_pct", label: "TARGET%", width: 8, align: "right", format: "percent" },
+  { id: "rating", label: "RATING", width: 7, align: "right", format: "number" },
+  { id: "ex_div", label: "EX-DIV", width: 7, align: "right" },
+  { id: "next_earn", label: "ERN", width: 7, align: "right" },
+  { id: "side", label: "SIDE", width: 5, align: "left" },
   { id: "shares", label: "SHARES", width: 9, align: "right", format: "number" },
   { id: "avg_cost", label: "AVG COST", width: 10, align: "right", format: "currency" },
   { id: "cost_basis", label: "COST", width: 10, align: "right", format: "compact" },
   { id: "mkt_value", label: "MKT VAL", width: 10, align: "right", format: "compact" },
+  { id: "weight", label: "WEIGHT", width: 8, align: "right", format: "percent" },
   { id: "day_pnl", label: "DAY", width: 10, align: "right", format: "compact" },
   { id: "pnl", label: "P&L", width: 10, align: "right", format: "compact" },
   { id: "pnl_pct", label: "P&L%", width: 8, align: "right", format: "percent" },
+  { id: "mark_delta", label: "MARK%", width: 8, align: "right", format: "percent" },
+  { id: "acq_date", label: "ACQ", width: 7, align: "right" },
+  { id: "held", label: "HELD", width: 6, align: "right" },
 ];
 
 const PORTFOLIO_COLUMNS_BY_ID = new Map(PORTFOLIO_COLUMN_DEFS.map((column) => [column.id, column]));
 const PORTFOLIO_ONLY_COLUMN_IDS = new Set([
+  "side",
   "shares",
   "avg_cost",
   "cost_basis",
   "mkt_value",
+  "weight",
   "day_pnl",
   "pnl",
   "pnl_pct",
+  "mark_delta",
+  "acq_date",
+  "held",
 ]);
 const COLLECTION_SCOPE_OPTIONS: PaneSettingOption[] = [
   {

package/src/plugins/builtin/portfolio-list/table.tsx

@@ -32,7 +32,7 @@ function buildCellVersion(
   financials: TickerFinancials | undefined,
   context: ColumnContext,
 ): string {
-  const latencyNow = column.id === "latency" ? context.now : 0;
+  const timeSensitiveNow = column.id === "latency" || column.id === "held" ? context.now : 0;
   return [
     column.id,
     objectVersion(ticker),
@@ -40,7 +40,9 @@ function buildCellVersion(
     objectVersion(context.exchangeRates),
     context.activeTab ?? "",
     context.baseCurrency,
-    latencyNow,
+    context.portfolioTotalMarketValue ?? 0,
+    context.supplementalVersion ?? 0,
+    timeSensitiveNow,
   ].join("|");
 }
 

package/src/plugins/builtin/portfolio-list/use-throttled-cursor-symbol.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useThrottledCommitValue } from "../../../react/use-throttled-commit-value";
 
 const FOLLOW_CURSOR_THROTTLE_MS = 150;
 
@@ -7,75 +7,17 @@ export function useThrottledCursorSymbol(
   setCommittedCursorSymbol: (symbol: string | null) => void,
   throttleMs = FOLLOW_CURSOR_THROTTLE_MS,
 ) {
-  const [cursorSymbol, setCursorSymbolState] = useState<string | null>(committedCursorSymbol);
-  const commitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const hasPendingCommitRef = useRef(false);
-  const pendingCursorSymbolRef = useRef<string | null>(committedCursorSymbol);
-  const appliedCursorSymbolRef = useRef<string | null>(committedCursorSymbol);
-
-  const clearPendingCursorCommit = useCallback(() => {
-    if (commitTimerRef.current) {
-      clearTimeout(commitTimerRef.current);
-      commitTimerRef.current = null;
-    }
-    hasPendingCommitRef.current = false;
-  }, []);
-
-  const commitCursorSymbol = useCallback((nextCursorSymbol?: string | null) => {
-    const targetCursorSymbol = nextCursorSymbol ?? pendingCursorSymbolRef.current;
-    clearPendingCursorCommit();
-    pendingCursorSymbolRef.current = targetCursorSymbol;
-
-    if (Object.is(appliedCursorSymbolRef.current, targetCursorSymbol)) {
-      return;
-    }
-
-    appliedCursorSymbolRef.current = targetCursorSymbol;
-    setCommittedCursorSymbol(targetCursorSymbol);
-  }, [clearPendingCursorCommit, setCommittedCursorSymbol]);
-
-  const scheduleCursorSymbol = useCallback((nextCursorSymbol: string | null, options?: { immediate?: boolean }) => {
-    setCursorSymbolState((current) => (Object.is(current, nextCursorSymbol) ? current : nextCursorSymbol));
-    pendingCursorSymbolRef.current = nextCursorSymbol;
-
-    if (options?.immediate) {
-      commitCursorSymbol(nextCursorSymbol);
-      return;
-    }
-
-    clearPendingCursorCommit();
-
-    if (Object.is(appliedCursorSymbolRef.current, nextCursorSymbol)) {
-      return;
-    }
-
-    hasPendingCommitRef.current = true;
-    commitTimerRef.current = setTimeout(() => {
-      commitCursorSymbol();
-    }, throttleMs);
-  }, [clearPendingCursorCommit, commitCursorSymbol, throttleMs]);
-
-  useEffect(() => {
-    if (hasPendingCommitRef.current && Object.is(committedCursorSymbol, pendingCursorSymbolRef.current)) {
-      clearPendingCursorCommit();
-    }
-
-    if (!hasPendingCommitRef.current) {
-      appliedCursorSymbolRef.current = committedCursorSymbol;
-      setCursorSymbolState((current) => (Object.is(current, committedCursorSymbol) ? current : committedCursorSymbol));
-    }
-  }, [clearPendingCursorCommit, committedCursorSymbol]);
-
-  useEffect(() => () => {
-    if (commitTimerRef.current) {
-      clearTimeout(commitTimerRef.current);
-    }
-  }, []);
+  const {
+    value: cursorSymbol,
+    setValue,
+    flushValue,
+    cancelPendingValue,
+  } = useThrottledCommitValue(committedCursorSymbol, setCommittedCursorSymbol, throttleMs);
 
   return {
     cursorSymbol,
-    setCursorSymbol: scheduleCursorSymbol,
-    flushCursorSymbol: commitCursorSymbol,
-    cancelPendingCursorSymbol: clearPendingCursorCommit,
+    setCursorSymbol: setValue,
+    flushCursorSymbol: flushValue,
+    cancelPendingCursorSymbol: cancelPendingValue,
   };
 }

package/src/plugins/builtin/substack/api/auth.ts

@@ -0,0 +1,185 @@
+import type { SubstackAuthState } from "./types";
+import {
+  parseErrorText,
+  resolveSubstackUrl,
+  storeSubstackAuth,
+  substackFetch,
+  SUBSTACK_ORIGIN,
+} from "./store";
+
+export async function requestSubstackMagicLink(email: string): Promise<void> {
+  const normalizedEmail = email.trim();
+  if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(normalizedEmail)) {
+    throw new Error("Enter a valid email address");
+  }
+  const response = await substackFetch(`${SUBSTACK_ORIGIN}/api/v1/email-login`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({ email: normalizedEmail }),
+  });
+  if (!response.ok) {
+    const detail = await parseErrorText(response);
+    throw new Error(`Substack login link failed (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+}
+
+export function splitSetCookieHeader(header: string): string[] {
+  const parts: string[] = [];
+  let start = 0;
+  let inExpires = false;
+  for (let i = 0; i < header.length; i += 1) {
+    const char = header[i];
+    if (char === ",") {
+      const fragment = header.slice(start, i);
+      inExpires = /expires=/i.test(fragment) && !/;\s*(?:max-age|domain|path|secure|httponly|samesite)\b/i.test(fragment);
+      if (!inExpires) {
+        parts.push(fragment.trim());
+        start = i + 1;
+      }
+    } else if (char === ";") {
+      inExpires = false;
+    }
+  }
+  const tail = header.slice(start).trim();
+  if (tail) parts.push(tail);
+  return parts;
+}
+
+function getSetCookieHeaders(headers: Headers): string[] {
+  const withGetSetCookie = headers as Headers & { getSetCookie?: () => string[] };
+  const direct = withGetSetCookie.getSetCookie?.();
+  if (direct && direct.length > 0) return direct;
+  const header = headers.get("set-cookie");
+  return header ? splitSetCookieHeader(header) : [];
+}
+
+export function parseCookiesFromSetCookie(headers: string[]): Map<string, string> {
+  const cookies = new Map<string, string>();
+  for (const header of headers) {
+    const first = header.split(";")[0] ?? "";
+    const eq = first.indexOf("=");
+    if (eq <= 0) continue;
+    const name = first.slice(0, eq).trim();
+    const value = first.slice(eq + 1).trim();
+    if (!name) continue;
+    cookies.set(name, value);
+  }
+  return cookies;
+}
+
+function cookieHeaderFromJar(jar: Map<string, string>): string {
+  return [...jar.entries()].map(([name, value]) => `${name}=${value}`).join("; ");
+}
+
+function mergeSetCookies(cookieJar: Map<string, string>, response: Response): void {
+  for (const [name, value] of parseCookiesFromSetCookie(getSetCookieHeaders(response.headers))) {
+    cookieJar.set(name, value);
+  }
+}
+
+async function followRedirectsForCookies(startUrl: string, cookieJar: Map<string, string>): Promise<void> {
+  let currentUrl = startUrl;
+  for (let redirectCount = 0; redirectCount < 8; redirectCount += 1) {
+    const response = await substackFetch(currentUrl, {
+      method: "GET",
+      redirect: "manual",
+      headers: cookieJar.size > 0 ? { cookie: cookieHeaderFromJar(cookieJar) } : undefined,
+    });
+    mergeSetCookies(cookieJar, response);
+
+    if (response.status < 300 || response.status >= 400) break;
+    const location = response.headers.get("location");
+    if (!location) break;
+    const nextUrl = resolveSubstackUrl(location, currentUrl);
+    if (!nextUrl) break;
+    currentUrl = nextUrl;
+  }
+}
+
+export async function completeSubstackMagicLink(link: string, email: string): Promise<SubstackAuthState> {
+  const currentUrl = resolveSubstackUrl(link);
+  if (!currentUrl) throw new Error("Paste the full Substack magic-link URL");
+
+  const cookieJar = new Map<string, string>();
+  await followRedirectsForCookies(currentUrl, cookieJar);
+
+  const sid = cookieJar.get("substack.sid");
+  if (!sid) {
+    throw new Error("Substack did not return a session cookie. Request a new login link and paste the full URL.");
+  }
+  const auth: SubstackAuthState = {
+    email: email.trim(),
+    sid,
+    lli: cookieJar.get("substack.lli") ?? "1",
+    loggedInAt: Date.now(),
+  };
+  storeSubstackAuth(auth);
+  return auth;
+}
+
+export async function completeSubstackOtpLogin(code: string, email: string): Promise<SubstackAuthState> {
+  const normalizedCode = code.trim();
+  const normalizedEmail = email.trim();
+  if (!/^\d{6}$/.test(normalizedCode)) {
+    throw new Error("Enter the 6-digit Substack email code");
+  }
+  if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(normalizedEmail)) {
+    throw new Error("Enter a valid email address");
+  }
+
+  const cookieJar = new Map<string, string>();
+  const response = await substackFetch(`${SUBSTACK_ORIGIN}/api/v1/email-otp-login/complete`, {
+    method: "POST",
+    redirect: "manual",
+    credentials: "include",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      code: normalizedCode,
+      email: normalizedEmail,
+      redirect: "",
+      for_pub: null,
+      island_magic_signin: false,
+    }),
+  });
+  mergeSetCookies(cookieJar, response);
+
+  const isRedirect = response.status >= 300 && response.status < 400;
+  if (!response.ok && !isRedirect) {
+    const detail = await parseErrorText(response);
+    throw new Error(`Substack code login failed (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+
+  let redirectUrl = resolveSubstackUrl(response.headers.get("location"));
+  if (!redirectUrl && response.ok) {
+    try {
+      const payload = await response.clone().json() as { redirect?: unknown };
+      redirectUrl = resolveSubstackUrl(payload.redirect);
+    } catch {
+      redirectUrl = null;
+    }
+  }
+
+  if (!cookieJar.get("substack.sid") && redirectUrl) {
+    await followRedirectsForCookies(redirectUrl, cookieJar);
+  }
+
+  const sid = cookieJar.get("substack.sid");
+  if (!sid) {
+    const capturedCookieNames = [...cookieJar.keys()];
+    throw new Error(
+      `Substack accepted the code but did not return a session cookie. status=${response.status} redirect=${redirectUrl ? "yes" : "no"} cookies=${capturedCookieNames.length ? capturedCookieNames.join(",") : "none"}`,
+    );
+  }
+  const auth: SubstackAuthState = {
+    email: normalizedEmail,
+    sid,
+    lli: cookieJar.get("substack.lli") ?? "1",
+    loggedInAt: Date.now(),
+  };
+  storeSubstackAuth(auth);
+  return auth;
+}