gloomberb 0.8.2 → 0.9.0

package/src/plugins/builtin/substack/table.ts

@@ -0,0 +1,111 @@
+import type {
+  SubstackArticleSummary,
+  SubstackColumn,
+  SubstackPublication,
+  SubstackSortColumnId,
+  SubstackSortDirection,
+} from "./types";
+import { publicationKey } from "./normalize";
+import { timestamp } from "./utils";
+
+export function isSubstackSortColumnId(value: string): value is SubstackSortColumnId {
+  return value === "published" || value === "publication" || value === "title" || value === "read";
+}
+
+export function nextSubstackSort(
+  current: { columnId: SubstackSortColumnId; direction: SubstackSortDirection },
+  columnId: SubstackSortColumnId,
+): { columnId: SubstackSortColumnId; direction: SubstackSortDirection } {
+  if (current.columnId === columnId) {
+    return { columnId, direction: current.direction === "desc" ? "asc" : "desc" };
+  }
+  return {
+    columnId,
+    direction: columnId === "title" || columnId === "publication" ? "asc" : "desc",
+  };
+}
+
+export function sortedSubstackArticles(
+  articles: SubstackArticleSummary[],
+  sort: { columnId: SubstackSortColumnId; direction: SubstackSortDirection },
+): SubstackArticleSummary[] {
+  const direction = sort.direction === "asc" ? 1 : -1;
+  return [...articles].sort((a, b) => {
+    let result = 0;
+    switch (sort.columnId) {
+      case "published":
+        result = timestamp(a.publishedAt) - timestamp(b.publishedAt);
+        break;
+      case "publication":
+        result = (a.publicationName ?? "").localeCompare(b.publicationName ?? "");
+        break;
+      case "title":
+        result = a.title.localeCompare(b.title);
+        break;
+      case "read":
+        result = a.readMinutes - b.readMinutes;
+        break;
+    }
+    return result === 0 ? timestamp(b.publishedAt) - timestamp(a.publishedAt) : result * direction;
+  });
+}
+
+export function formatPublishedAt(value: string | null): string {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  const now = new Date();
+  const sameYear = date.getFullYear() === now.getFullYear();
+  const datePart = date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    ...(sameYear ? {} : { year: "2-digit" as const }),
+  });
+  const timePart = date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+  return `${datePart} ${timePart}`;
+}
+
+export function formatReadTime(minutes: number): string {
+  return `${Math.max(1, Math.ceil(minutes))}m`;
+}
+
+export function formatWordCount(words: number): string {
+  if (words >= 1000) return `${(words / 1000).toFixed(words >= 10_000 ? 0 : 1)}k words`;
+  return `${Math.max(0, Math.round(words))} words`;
+}
+
+export function buildSubstackColumns(width: number, includePublication: boolean): SubstackColumn[] {
+  const publishedWidth = 13;
+  const readWidth = 5;
+  const publicationWidth = includePublication ? Math.max(12, Math.min(21, Math.floor(width * 0.18))) : 0;
+  const fixed = publishedWidth + readWidth + publicationWidth;
+  const titleWidth = Math.max(18, width - fixed - 4);
+  const columns: SubstackColumn[] = [
+    { id: "published", label: "Published", width: publishedWidth, align: "left" },
+  ];
+  if (includePublication) {
+    columns.push({ id: "publication", label: "Publication", width: publicationWidth, align: "left" });
+  }
+  columns.push(
+    { id: "title", label: "Title", width: titleWidth, align: "left", flexGrow: 1 },
+    { id: "read", label: "Read", width: readWidth, align: "right" },
+  );
+  return columns;
+}
+
+export function tabIdForPublication(publication: SubstackPublication): string {
+  return `pub:${publicationKey(publication)}`;
+}
+
+export function publicationFromTabId(
+  tabId: string,
+  publications: SubstackPublication[],
+): SubstackPublication | null {
+  if (!tabId.startsWith("pub:")) return null;
+  const key = tabId.slice(4);
+  return publications.find((publication) => publicationKey(publication) === key) ?? null;
+}

package/src/plugins/builtin/substack/types.ts

@@ -0,0 +1,71 @@
+import type { DataTableColumn } from "../../../components";
+
+export const SUBSTACK_PANE_ID = "substack";
+export const SUBSTACK_PLUGIN_ID = "substack";
+export const SUBSTACK_FEED_TAB_ID = "feed";
+
+export interface SubstackPublication {
+  id: string;
+  name: string;
+  subdomain: string | null;
+  baseUrl: string | null;
+  description: string | null;
+  logoUrl: string | null;
+  latestPublishedAt: string | null;
+}
+
+export interface ExtractedArticleContent {
+  text: string;
+  blocks: SubstackContentBlock[];
+  imageUrls: string[];
+  linkUrls: string[];
+  wordCount: number;
+  readMinutes: number;
+}
+
+export type SubstackContentBlock =
+  | { type: "heading"; text: string; level: number }
+  | { type: "paragraph"; text: string }
+  | { type: "quote"; text: string }
+  | { type: "listItem"; text: string }
+  | { type: "image"; url: string; alt: string | null }
+  | {
+    type: "embed";
+    kind: "tweet";
+    text: string;
+    url: string | null;
+    username: string | null;
+    authorName: string | null;
+    dateLabel: string | null;
+    imageUrls: string[];
+  }
+  | { type: "embed"; kind: "link" | "media"; text: string; url: string | null }
+  | { type: "divider" };
+
+export interface SubstackArticleSummary {
+  id: string;
+  title: string;
+  publicationId: string | null;
+  publicationName: string | null;
+  publicationSubdomain: string | null;
+  publicationBaseUrl: string | null;
+  url: string | null;
+  slug: string | null;
+  publishedAt: string | null;
+  subtitle: string | null;
+  previewText: string | null;
+  bodyHtml: string | null;
+  imageUrls: string[];
+  wordCount: number;
+  readMinutes: number;
+}
+
+export interface SubstackArticleDetail extends SubstackArticleSummary {
+  contentText: string;
+  contentBlocks: SubstackContentBlock[];
+  linkUrls: string[];
+}
+
+export type SubstackSortColumnId = "published" | "publication" | "title" | "read";
+export type SubstackSortDirection = "asc" | "desc";
+export type SubstackColumn = DataTableColumn & { id: SubstackSortColumnId };

package/src/plugins/builtin/substack/utils.ts

@@ -0,0 +1,131 @@
+import { decodeHtmlEntities } from "../../../utils/html-entities";
+import { normalizedHttpUrl } from "../../../utils/url";
+
+export type JsonRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is JsonRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function asRecord(value: unknown): JsonRecord | null {
+  return isRecord(value) ? value : null;
+}
+
+export function stringValue(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = decodeHtmlEntities(value).replace(/\s+/g, " ").trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function rawStringValue(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function numberValue(value: unknown): number | null {
+  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;
+}
+
+export function firstString(record: JsonRecord | null, keys: string[]): string | null {
+  if (!record) return null;
+  for (const key of keys) {
+    const value = stringValue(record[key]);
+    if (value) return value;
+  }
+  return null;
+}
+
+export function firstRawString(record: JsonRecord | null, keys: string[]): string | null {
+  if (!record) return null;
+  for (const key of keys) {
+    const value = rawStringValue(record[key]);
+    if (value) return value;
+  }
+  return null;
+}
+
+export function firstNumber(record: JsonRecord | null, keys: string[]): number | null {
+  if (!record) return null;
+  for (const key of keys) {
+    const value = numberValue(record[key]);
+    if (value != null) return value;
+  }
+  return null;
+}
+
+export function firstValue(record: JsonRecord | null, keys: string[]): unknown {
+  if (!record) return null;
+  for (const key of keys) {
+    if (record[key] != null) return record[key];
+  }
+  return null;
+}
+
+export function firstRecord(...values: unknown[]): JsonRecord | null {
+  for (const value of values) {
+    const record = asRecord(value);
+    if (record) return record;
+  }
+  return null;
+}
+
+export function parseDateIso(value: unknown): string | null {
+  if (value == null) return null;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = value > 10_000_000_000 ? value : value * 1000;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+  }
+  if (typeof value !== "string" || !value.trim()) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+export function normalizeUrl(value: unknown, baseUrl?: string | null): string | null {
+  const raw = rawStringValue(value);
+  if (!raw) return null;
+  const direct = normalizedHttpUrl(raw);
+  if (direct) return direct;
+  if (!baseUrl) return null;
+  try {
+    const resolved = new URL(raw, baseUrl);
+    return normalizedHttpUrl(resolved.toString());
+  } catch {
+    return null;
+  }
+}
+
+export function uniqueStrings(values: Array<string | null | undefined>): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values) {
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
+}
+
+export function timestamp(value: string | null | undefined): number {
+  if (!value) return 0;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? 0 : date.getTime();
+}
+
+export function maxIso(a: string | null, b: string | null): string | null {
+  if (!a) return b;
+  if (!b) return a;
+  return timestamp(a) >= timestamp(b) ? a : b;
+}
+
+export function extractAttribute(tag: string, name: string): string | null {
+  const pattern = new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i");
+  const match = tag.match(pattern);
+  return rawStringValue(match?.[1] ?? match?.[2] ?? match?.[3] ?? null);
+}

package/src/plugins/builtin/ticker-detail/index.test.tsx

@@ -41,6 +41,7 @@ let detailHarnessState: ReturnType<typeof createInitialState> | null = null;
 let sharedCoordinator: MarketDataCoordinator | null = null;
 
 const runtime = createTestPluginRuntime();
+const TICKER_TAB_SETTLE_MS = 160;
 
 const DetailPane = tickerDetailPlugin.panes![0]!.component as (props: {
   paneId: string;
@@ -160,7 +161,7 @@ function setOptionsProvider(provider: DataProvider | undefined): void {
   setSharedMarketDataCoordinator(sharedCoordinator);
 }
 
-function makeRegistry(): PluginRegistry {
+function makeRegistry(options: { stubFundamentalGraphs?: boolean } = {}): PluginRegistry {
   const stubTab = (_props: { width: number; height: number; focused: boolean; onCapture: (capturing: boolean) => void }) => (
     <text>stub</text>
   );
@@ -168,6 +169,10 @@ function makeRegistry(): PluginRegistry {
   tickerDetailPlugin.setup?.({
     registerTickerResearchTab: (tab: TickerResearchTabDef) => tickerResearchTabs.set(tab.id, tab),
   } as any);
+  if (options.stubFundamentalGraphs) {
+    const tab = tickerResearchTabs.get("fundamental-graphs");
+    if (tab) tickerResearchTabs.set(tab.id, { ...tab, component: stubTab });
+  }
   for (const tab of [
     ["ibkr-trade", {
       id: "ibkr-trade",
@@ -280,6 +285,13 @@ async function flushFrame() {
   });
 }
 
+async function settleTickerTabCommit() {
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, TICKER_TAB_SETTLE_MS));
+    await testSetup!.renderOnce();
+  });
+}
+
 async function clickFrameText(text: string) {
   const lines = testSetup!.captureCharFrame().split("\n");
   const row = lines.findIndex((line) => line.includes(text));
@@ -482,7 +494,7 @@ describe("TickerResearchPane", () => {
   });
 
   test("lets ticker detail tab arrows leave the embedded financials tab", async () => {
-    setSharedRegistryForTests(makeRegistry());
+    setSharedRegistryForTests(makeRegistry({ stubFundamentalGraphs: true }));
     setOptionsProvider(createProvider(false));
 
     testSetup = await testRender(
@@ -506,6 +518,7 @@ describe("TickerResearchPane", () => {
     });
     await flushFrame();
 
+    await settleTickerTabCommit();
     expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
 
     await act(async () => {
@@ -514,6 +527,7 @@ describe("TickerResearchPane", () => {
     });
     await flushFrame();
 
+    await settleTickerTabCommit();
     expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("financials");
   });
 

package/src/plugins/builtin/ticker-detail/index.tsx

@@ -146,6 +146,7 @@ export const tickerDetailPlugin: GloomPlugin = {
       label: "Ticker Research",
       description: "Open another research pane for the selected ticker or current collection",
       keywords: ["new", "ticker", "research", "detail", "pane", "inspector"],
+      shortcut: { prefix: "T", argPlaceholder: "ticker", argKind: "ticker" },
       canCreate: (context) => context.activeTicker !== null || context.activeCollectionId !== null,
       createInstance: (context) => (
         context.activeTicker

package/src/plugins/builtin/ticker-detail/pane.tsx

@@ -14,6 +14,7 @@ import { useQuoteStreaming } from "../../../state/hooks/quote-streaming";
 import { getCollectionName, getCollectionTickerCount } from "../../../state/selectors";
 import { getSharedRegistry } from "../../registry";
 import { EmptyState, PaneFooterScope, Tabs } from "../../../components";
+import { useThrottledCommitValue } from "../../../react/use-throttled-commit-value";
 import { resolveOptionsTarget } from "../../../utils/options";
 import {
   buildVisibleTickerResearchTabs,
@@ -21,6 +22,8 @@ import {
   resolveLockedTabId,
 } from "./settings";
 
+const TICKER_RESEARCH_TAB_COMMIT_DELAY_MS = 120;
+
 function sameStringSet(left: Set<string>, right: Set<string>): boolean {
   if (left.size !== right.size) return false;
   for (const value of left) {
@@ -79,7 +82,16 @@ export function TickerResearchPane({ focused, width, height }: PaneProps) {
   useQuoteStreaming(streamingTargets);
 
   const { collectionId } = usePaneCollection();
-  const [activeTabId, setActiveTabId] = usePaneStateValue<string>("activeTabId", "overview");
+  const [committedActiveTabId, setCommittedActiveTabId] = usePaneStateValue<string>("activeTabId", "overview");
+  const {
+    value: activeTabId,
+    setValue: setActiveTabId,
+  } = useThrottledCommitValue(
+    committedActiveTabId,
+    setCommittedActiveTabId,
+    TICKER_RESEARCH_TAB_COMMIT_DELAY_MS,
+    { commitPendingOnUnmount: true },
+  );
   const [pluginCaptured, setPluginCaptured] = useState(false);
   const [mountedTabIds, setMountedTabIds] = useState<Set<string>>(() => new Set());
   const paneSettings = getTickerResearchPaneSettings(paneInstance?.settings);

package/src/plugins/catalog-ui.ts

@@ -2,6 +2,7 @@ import type { GloomPlugin } from "../types/plugin";
 import { portfolioListPlugin } from "./builtin/portfolio-list";
 import { newsPlugin } from "./builtin/news";
 import { notesPlugin } from "./builtin/notes";
+import { substackPlugin } from "./builtin/substack";
 import { aiPlugin } from "./builtin/ai";
 import { gloomberbCloudPlugin } from "./builtin/cloud";
 import { changelogPlugin } from "./builtin/changelog";
@@ -26,6 +27,7 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   ibkrPlugin,
   layoutManagerPlugin,
   newsPlugin,
+  substackPlugin,
   notesPlugin,
   aiPlugin,
   changelogPlugin,

package/src/plugins/pane-manager/layout-state.ts

@@ -158,3 +158,14 @@ export function removePane(layout: LayoutConfig, instanceId: string): LayoutConf
     [instanceId],
   ));
 }
+
+export function removeFloatingPanes(layout: LayoutConfig): LayoutConfig {
+  if (layout.floating.length === 0) return layout;
+  return finalizeLayout(removePaneInstances(
+    {
+      ...layout,
+      floating: [],
+    },
+    layout.floating.map((entry) => entry.instanceId),
+  ));
+}

package/src/plugins/pane-manager.ts

@@ -49,7 +49,7 @@ export {
   swapPanes,
 } from "./pane-manager/docking";
 
-export { removePane } from "./pane-manager/layout-state";
+export { removeFloatingPanes, removePane } from "./pane-manager/layout-state";
 export { gridlockAllPanes } from "./pane-manager/gridlock";
 export type {
   DropTarget,

package/src/react/use-throttled-commit-value.ts

@@ -0,0 +1,116 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export function useThrottledCommitValue<T>(
+  committedValue: T,
+  commitValue: (value: T) => void,
+  delayMs: number,
+  options?: { commitPendingOnUnmount?: boolean },
+) {
+  const [value, setValueState] = useState<T>(committedValue);
+  const valueRef = useRef<T>(committedValue);
+  const commitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const hasPendingCommitRef = useRef(false);
+  const pendingValueRef = useRef<T>(committedValue);
+  const appliedValueRef = useRef<T>(committedValue);
+  const commitValueRef = useRef(commitValue);
+  const optionsRef = useRef(options);
+
+  useEffect(() => {
+    commitValueRef.current = commitValue;
+  }, [commitValue]);
+
+  useEffect(() => {
+    optionsRef.current = options;
+  }, [options]);
+
+  const clearPendingCommit = useCallback(() => {
+    if (commitTimerRef.current) {
+      clearTimeout(commitTimerRef.current);
+      commitTimerRef.current = null;
+    }
+    hasPendingCommitRef.current = false;
+  }, []);
+
+  const flushValue = useCallback((...args: [] | [T]) => {
+    const targetValue = args.length === 0 ? pendingValueRef.current : args[0];
+    clearPendingCommit();
+    pendingValueRef.current = targetValue;
+    valueRef.current = targetValue;
+    setValueState((current) => (Object.is(current, targetValue) ? current : targetValue));
+
+    if (Object.is(appliedValueRef.current, targetValue)) {
+      return;
+    }
+
+    appliedValueRef.current = targetValue;
+    commitValueRef.current(targetValue);
+  }, [clearPendingCommit]);
+
+  const replaceValue = useCallback((nextValue: T) => {
+    clearPendingCommit();
+    appliedValueRef.current = nextValue;
+    pendingValueRef.current = nextValue;
+    valueRef.current = nextValue;
+    setValueState((current) => (Object.is(current, nextValue) ? current : nextValue));
+  }, [clearPendingCommit]);
+
+  const setValue = useCallback((nextValue: T, options?: { immediate?: boolean }) => {
+    valueRef.current = nextValue;
+    pendingValueRef.current = nextValue;
+    setValueState((current) => (Object.is(current, nextValue) ? current : nextValue));
+
+    if (options?.immediate) {
+      flushValue(nextValue);
+      return;
+    }
+
+    clearPendingCommit();
+
+    if (Object.is(appliedValueRef.current, nextValue)) {
+      return;
+    }
+
+    hasPendingCommitRef.current = true;
+    commitTimerRef.current = setTimeout(() => {
+      flushValue();
+    }, delayMs);
+  }, [clearPendingCommit, delayMs, flushValue]);
+
+  useEffect(() => {
+    if (hasPendingCommitRef.current && Object.is(committedValue, pendingValueRef.current)) {
+      clearPendingCommit();
+    }
+
+    if (!hasPendingCommitRef.current) {
+      appliedValueRef.current = committedValue;
+      pendingValueRef.current = committedValue;
+      valueRef.current = committedValue;
+      setValueState((current) => (Object.is(current, committedValue) ? current : committedValue));
+    }
+  }, [clearPendingCommit, committedValue]);
+
+  useEffect(() => () => {
+    const pending = hasPendingCommitRef.current;
+    const pendingValue = pendingValueRef.current;
+    if (commitTimerRef.current) {
+      clearTimeout(commitTimerRef.current);
+    }
+    if (
+      optionsRef.current?.commitPendingOnUnmount
+      && pending
+      && !Object.is(appliedValueRef.current, pendingValue)
+    ) {
+      appliedValueRef.current = pendingValue;
+      commitValueRef.current(pendingValue);
+    }
+  }, []);
+
+  return {
+    value,
+    valueRef,
+    setValue,
+    flushValue,
+    replaceValue,
+    cancelPendingValue: clearPendingCommit,
+  };
+}

package/src/renderers/electrobun/bun/desktop/http-fetch.test.ts

@@ -0,0 +1,42 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { handleHttpFetch } from "./http-fetch";
+
+let server: ReturnType<typeof Bun.serve> | null = null;
+
+afterEach(() => {
+  server?.stop(true);
+  server = null;
+});
+
+describe("handleHttpFetch", () => {
+  test("preserves manual redirects and Set-Cookie headers", async () => {
+    server = Bun.serve({
+      port: 0,
+      fetch(request) {
+        const url = new URL(request.url);
+        if (url.pathname === "/login") {
+          return new Response(null, {
+            status: 302,
+            headers: {
+              location: "/reader",
+              "set-cookie": "substack.sid=sid123; Path=/; HttpOnly",
+            },
+          });
+        }
+        if (url.pathname === "/reader") {
+          return new Response("reader");
+        }
+        return new Response("not found", { status: 404 });
+      },
+    });
+
+    const response = await handleHttpFetch({
+      url: new URL("/login", server.url).toString(),
+      init: { redirect: "manual" },
+    });
+
+    expect(response.status).toBe(302);
+    expect(response.headers.location).toBe("/reader");
+    expect(response.setCookie).toEqual(["substack.sid=sid123; Path=/; HttpOnly"]);
+  });
+});

package/src/renderers/electrobun/bun/desktop/http-fetch.ts

@@ -26,6 +26,10 @@ export async function handleHttpFetch(payload: Record<string, unknown>) {
     typeof init.method === "string" && init.method.trim().length > 0
       ? init.method.trim().toUpperCase()
       : "GET";
+  const redirect =
+    init.redirect === "manual" || init.redirect === "error" || init.redirect === "follow"
+      ? init.redirect
+      : undefined;
   const body =
     typeof init.body === "string" && method !== "GET" && method !== "HEAD"
       ? init.body
@@ -35,6 +39,7 @@ export async function handleHttpFetch(payload: Record<string, unknown>) {
     method,
     headers: normalizeHttpFetchHeaders(init.headers),
     body,
+    redirect,
   });
   const responseHeaders: Record<string, string> = {};
   response.headers.forEach((value, key) => {

package/src/renderers/electrobun/view/http-fetch.ts

@@ -61,12 +61,18 @@ async function electrobunHttpFetch(url: string, init?: RequestInit): Promise<Res
   const requestPromise = requestBackendHttpFetch(url, init);
 
   const response = await withAbort(requestPromise, init?.signal);
-
-  return new Response(response.body, {
+  const headers = createResponseHeaders(response.headers, response.setCookie);
+  const fetchResponse = new Response(response.body, {
     status: response.status,
     statusText: response.statusText,
-    headers: response.headers,
+    headers,
+  });
+
+  Object.defineProperty(fetchResponse, "headers", {
+    value: headers,
+    configurable: true,
   });
+  return fetchResponse;
 }
 
 async function requestBackendHttpFetch(url: string, init?: RequestInit): Promise<ElectrobunHttpFetchResponse> {
@@ -76,6 +82,7 @@ async function requestBackendHttpFetch(url: string, init?: RequestInit): Promise
       method: init?.method,
       headers: normalizeHeaders(init?.headers),
       body: await serializeBody(init?.body),
+      redirect: init?.redirect,
     },
   });
 }