gloomberb 0.10.2 → 0.10.4

package/src/renderers/electrobun/view/data-table/index.tsx

@@ -15,7 +15,9 @@ import { measurePerf } from "../../../../utils/perf-marks";
 import type {
   DataTableColumn,
   DataTableProps,
+  DataTableVisibleRange,
 } from "../../../../components/ui/data-table";
+import { resolveDataTableVisibleRange } from "../../../../components/ui/data-table/visible-range";
 import {
   buildTableGridTemplateColumns,
   getTableWidth,
@@ -57,6 +59,8 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
   onSelect,
   onActivate,
   onTableMouseDown,
+  visibleRangeKey,
+  onVisibleRangeChange,
   onRowMouseDown,
   onRowContextMenu,
   rowContextMenuSurface = false,
@@ -80,6 +84,10 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
   const dispatch = useAppDispatch();
   const paneInstanceId = usePaneInstance()?.instanceId ?? null;
   const bodyElementRef = useRef<HTMLDivElement | null>(null);
+  const lastVisibleRangeRef = useRef<{
+    key: string | number | undefined;
+    range: DataTableVisibleRange;
+  } | null>(null);
   const headerHorizontal = useScrollbarState(false);
   const headerVertical = useScrollbarState(false);
   const bodyHorizontal = useScrollbarState(showHorizontalScrollbar);
@@ -106,10 +114,32 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
     dispatch({ type: "FOCUS_PANE", paneId: paneInstanceId });
   }, [dispatch, paneInstanceId]);
 
+  const emitVisibleRange = useCallback(() => {
+    if (!onVisibleRangeChange) return;
+    const element = bodyElementRef.current;
+    if (!element) return;
+    const range = resolveDataTableVisibleRange({
+      itemCount: items.length,
+      rowSize: WEB_CELL_HEIGHT,
+      scrollOffset: element.scrollTop,
+      viewportSize: Math.max(0, element.clientHeight - WEB_CELL_HEIGHT),
+    });
+    const previous = lastVisibleRangeRef.current;
+    if (
+      previous !== null
+      && previous.key === visibleRangeKey
+      && previous.range.start === range.start
+      && previous.range.end === range.end
+    ) return;
+    lastVisibleRangeRef.current = { key: visibleRangeKey, range };
+    onVisibleRangeChange(range);
+  }, [items.length, onVisibleRangeChange, visibleRangeKey]);
   const handleBodyScrollActivity = useCallback(() => {
     onBodyScrollActivity();
-  }, [onBodyScrollActivity]);
+    emitVisibleRange();
+  }, [emitVisibleRange, onBodyScrollActivity]);
   const scheduleBodyScrollActivity = useRafCallback(handleBodyScrollActivity);
+  const scheduleVisibleRangeMeasure = useRafCallback(emitVisibleRange);
 
   const rowVirtualizer = useVirtualizer({
     count: items.length,
@@ -154,12 +184,20 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
 
   useEffect(() => {
     measureViewportWidth();
+    scheduleVisibleRangeMeasure();
     const element = bodyElementRef.current;
     if (!element || typeof ResizeObserver === "undefined") return;
-    const observer = new ResizeObserver(scheduleViewportWidthMeasure);
+    const observer = new ResizeObserver(() => {
+      scheduleViewportWidthMeasure();
+      scheduleVisibleRangeMeasure();
+    });
     observer.observe(element);
     return () => observer.disconnect();
-  }, [measureViewportWidth, scheduleViewportWidthMeasure]);
+  }, [measureViewportWidth, scheduleViewportWidthMeasure, scheduleVisibleRangeMeasure]);
+
+  useEffect(() => {
+    scheduleVisibleRangeMeasure();
+  }, [items.length, scheduleVisibleRangeMeasure, visibleRangeKey]);
 
   useEffect(() => {
     if (scrollToIndex == null || items.length === 0) return;
@@ -168,6 +206,7 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
       rowVirtualizer.scrollToIndex(targetIndex, {
         align: scrollToIndexAlign === "center" ? "center" : "auto",
       });
+      scheduleVisibleRangeMeasure();
       return;
     }
     const element = bodyElementRef.current;
@@ -185,12 +224,14 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
     if (nextTop !== currentTop) {
       element.scrollTop = nextTop * WEB_CELL_HEIGHT;
     }
+    scheduleVisibleRangeMeasure();
   }, [
     items.length,
     rowVirtualizer,
     scrollToIndex,
     scrollToIndexAlign,
     scrollToIndexVersion,
+    scheduleVisibleRangeMeasure,
     virtualize,
   ]);
 

package/src/renderers/electrobun/view/host/box.test.tsx

@@ -0,0 +1,97 @@
+/** @jsxImportSource react */
+import { Window } from "happy-dom";
+
+// The desktop host is the only renderer with a real DOM underneath it, so its
+// mouse contract needs a DOM to be tested against.
+const testWindow = new Window({ url: "http://localhost" });
+Object.assign(globalThis, {
+  window: testWindow,
+  document: testWindow.document,
+  navigator: testWindow.navigator,
+  MouseEvent: testWindow.MouseEvent,
+  Event: testWindow.Event,
+  HTMLElement: testWindow.HTMLElement,
+  Node: testWindow.Node,
+  requestAnimationFrame: (callback: (time: number) => void) => setTimeout(() => callback(Date.now()), 8),
+  cancelAnimationFrame: (id: number) => clearTimeout(id),
+});
+
+import { expect, test } from "bun:test";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { WebChartSurface } from "./chart-surface";
+
+async function settle() {
+  await new Promise((resolve) => setTimeout(resolve, 30));
+}
+
+test("reports a drag as a drag, never as a move, and keeps its modifiers", async () => {
+  const seen: string[] = [];
+  const modifiers: Array<{ shift: boolean; alt: boolean }> = [];
+  const container = testWindow.document.createElement("div");
+  testWindow.document.body.appendChild(container);
+  const root = createRoot(container as unknown as HTMLElement);
+  await act(async () => {
+    root.render(
+      <WebChartSurface
+        width={40}
+        height={10}
+        onMouseMove={() => seen.push("move")}
+        onMouseDown={(event: { modifiers: { shift: boolean; alt: boolean } }) => {
+          seen.push("down");
+          modifiers.push(event.modifiers);
+        }}
+        onMouseDrag={(event: { modifiers: { shift: boolean; alt: boolean } }) => {
+          seen.push("drag");
+          modifiers.push(event.modifiers);
+        }}
+        onMouseUp={() => seen.push("up")}
+      />,
+    );
+  });
+  const surface = container.firstElementChild as unknown as HTMLElement;
+  const mouse = (type: string, target: { dispatchEvent: (event: unknown) => unknown }, clientX: number) => {
+    target.dispatchEvent(new MouseEvent(type, { bubbles: true, button: 0, clientX, clientY: 24, shiftKey: true }));
+  };
+
+  await act(async () => {
+    mouse("mousemove", surface, 10);
+    await settle();
+  });
+  await act(async () => mouse("mousedown", surface, 10));
+  await act(async () => {
+    // The DOM delivers both while a button is held; only the drag may surface.
+    mouse("mousemove", surface, 80);
+    mouse("mousemove", testWindow.document as never, 80);
+    await settle();
+  });
+  await act(async () => mouse("mouseup", testWindow.document as never, 80));
+
+  expect(seen).toEqual(["move", "down", "drag", "up"]);
+  expect(modifiers.every((entry) => entry.shift)).toBe(true);
+});
+
+test("a tab bar occupies exactly the one row panes reserve for it", async () => {
+  const { WebTabs } = await import("./tabs");
+  const { WEB_CELL_HEIGHT } = await import("../input-host");
+  const container = testWindow.document.createElement("div");
+  testWindow.document.body.appendChild(container);
+  const root = createRoot(container as unknown as HTMLElement);
+  await act(async () => {
+    root.render(
+      <WebTabs
+        tabs={[{ label: "Overview", value: "overview" }, { label: "Chart", value: "chart" }]}
+        activeValue="chart"
+        onSelect={() => {}}
+        palette={{} as never}
+      />,
+    );
+  });
+  await settle();
+  const list = container.querySelector('[data-gloom-role="tab-list"]') as unknown as HTMLElement;
+  // Panes size their content as `height - 1` for the tab bar. Any extra pixel
+  // here is a pixel the content is told it owns and the pane then clips.
+  expect(list.style.height).toBe(`${WEB_CELL_HEIGHT}px`);
+  expect(list.style.marginBottom === "" || list.style.marginBottom === "0px").toBe(true);
+  await act(async () => root.unmount());
+});

package/src/renderers/electrobun/view/host/box.tsx

@@ -65,6 +65,9 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
     };
 
     const scheduleFrameMouseHandler = (event: MouseLikeEvent, type: "move" | "drag") => {
+      // The DOM keeps firing mousemove while a button is held. A move means no
+      // button anywhere else in the app, so drags must not surface as moves.
+      if (type === "move" && draggingRef.current) return;
       if (type === "move" && typeof propsRef.current.onMouseMove !== "function") return;
       if (type === "drag"
         && typeof propsRef.current.onMouse !== "function"

package/src/renderers/electrobun/view/host/chart-surface.tsx

@@ -8,7 +8,12 @@ import {
   type ReactNode,
   type Ref,
 } from "react";
-import type { BitmapSurface, BoxRenderable, ChartCrosshairOverlay } from "../../../../ui/host";
+import type {
+  BitmapSurface,
+  BoxRenderable,
+  ChartCrosshairOverlay,
+  ChartVectorShape,
+} from "../../../../ui/host";
 import { WebBox } from "./box";
 
 const CanvasBitmap = memo(function CanvasBitmap({ bitmap }: { bitmap: BitmapSurface }) {
@@ -54,6 +59,83 @@ const BoxLayer = memo(function BoxLayer({ bitmap, index }: { bitmap: BitmapSurfa
   );
 });
 
+const ChartVectors = memo(function ChartVectors({ vectors }: { vectors: readonly ChartVectorShape[] }) {
+  if (vectors.length === 0) return null;
+  return (
+    <>
+      <svg
+        viewBox="0 0 1 1"
+        preserveAspectRatio="none"
+        // An SVG is a replaced element: without an explicit size it falls back
+        // to its intrinsic box and squeezes the whole overlay into a corner.
+        style={{
+          position: "absolute",
+          inset: 0,
+          width: "100%",
+          height: "100%",
+          pointerEvents: "none",
+          zIndex: 9,
+        }}
+      >
+        {vectors.map((shape) => {
+          const strokeWidth = shape.strokeWidth ?? 1.4;
+          const [first, second] = shape.points;
+          if (shape.box && first && second) {
+            return (
+              <rect
+                key={shape.id}
+                x={Math.min(first.x, second.x)}
+                y={Math.min(first.y, second.y)}
+                width={Math.abs(second.x - first.x)}
+                height={Math.abs(second.y - first.y)}
+                fill={shape.color}
+                fillOpacity={shape.fillOpacity ?? 0.18}
+                stroke={shape.color}
+                strokeWidth={strokeWidth}
+                vectorEffect="non-scaling-stroke"
+              />
+            );
+          }
+          return (
+            <polyline
+              key={shape.id}
+              points={shape.points.map((point) => `${point.x},${point.y}`).join(" ")}
+              fill="none"
+              stroke={shape.color}
+              strokeWidth={strokeWidth}
+              strokeLinecap="round"
+              strokeLinejoin="round"
+              vectorEffect="non-scaling-stroke"
+            />
+          );
+        })}
+      </svg>
+      {/* Ratio space is anisotropic, so handles are placed instead of scaled. */}
+      {vectors.flatMap((shape) => shape.handles
+        ? shape.points.map((point, index) => (
+          <div
+            key={`${shape.id}:${index}`}
+            style={{
+              position: "absolute",
+              left: `${point.x * 100}%`,
+              top: `${point.y * 100}%`,
+              width: 9,
+              height: 9,
+              borderRadius: 999,
+              border: `2px solid ${shape.color}`,
+              backgroundColor: "var(--gloom-bg)",
+              boxSizing: "border-box",
+              transform: "translate(-50%, -50%)",
+              pointerEvents: "none",
+              zIndex: 10,
+            }}
+          />
+        ))
+        : [])}
+    </>
+  );
+});
+
 function ChartCrosshair({
   bitmap,
   crosshair,
@@ -122,6 +204,7 @@ export const WebChartSurface = forwardRef<BoxRenderable, Record<string, unknown>
     const bitmaps = (props.bitmaps ?? null) as readonly BitmapSurface[] | null;
     const layers = bitmaps ?? (bitmap ? [bitmap] : []);
     const crosshair = (props.crosshair ?? null) as ChartCrosshairOverlay | null;
+    const vectors = (props.vectors ?? null) as readonly ChartVectorShape[] | null;
     const baseLayer = layers[0] ?? null;
     return (
       <WebBox
@@ -135,6 +218,7 @@ export const WebChartSurface = forwardRef<BoxRenderable, Record<string, unknown>
             <BoxLayer key={`layer:${index}`} index={index} bitmap={layer} />
           ))
           : children as ReactNode}
+        <ChartVectors vectors={vectors ?? []} />
         <ChartCrosshair bitmap={baseLayer} crosshair={crosshair} />
       </WebBox>
     );

package/src/renderers/electrobun/view/host/focus-scope.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { isEditableTarget, shouldReleaseFocus } from "./focus-scope";
+
+function field(scope?: { contains: (node: unknown) => boolean }) {
+  return {
+    tagName: "INPUT",
+    closest: () => scope ?? null,
+    contains: (node: unknown) => node === undefined,
+  };
+}
+
+describe("focus scope release", () => {
+  test("releases focus for a press outside the widget that owns it", () => {
+    expect(shouldReleaseFocus(field(), { tagName: "DIV" })).toBe(true);
+  });
+
+  test("keeps focus for a press on the owning widget's own chrome", () => {
+    const suggestion = { tagName: "DIV" };
+    expect(shouldReleaseFocus(field({ contains: (n) => n === suggestion }), suggestion)).toBe(false);
+  });
+
+  test("ignores presses while nothing editable holds focus", () => {
+    expect(shouldReleaseFocus({ tagName: "DIV", closest: () => null }, {})).toBe(false);
+    expect(shouldReleaseFocus(null, {})).toBe(false);
+  });
+
+  test("leaves a press inside a dialog alone, which owns the pointer itself", () => {
+    const inDialog = { tagName: "INPUT", closest: (selector: string) => selector === ".gloom-dialog" ? {} : null };
+    expect(shouldReleaseFocus(field(), inDialog)).toBe(false);
+  });
+
+  test("recognises the field a press is about to focus", () => {
+    expect(isEditableTarget({ tagName: "textarea" })).toBe(true);
+    expect(isEditableTarget({ isContentEditable: true })).toBe(true);
+    expect(isEditableTarget({ tagName: "canvas" })).toBe(false);
+  });
+});

package/src/renderers/electrobun/view/host/focus-scope.ts

@@ -0,0 +1,56 @@
+/**
+ * The browser gives up a field's focus when you press somewhere else. Panes,
+ * charts and rows all consume their own mousedown, which is exactly what
+ * suppresses that, so a field can hold the keyboard long after it looks done.
+ *
+ * One rule restores the default: a press outside the widget that owns the focus
+ * releases it. Widgets whose own chrome must not take focus from their field,
+ * such as a suggestion list under an input, mark it with the scope attribute.
+ *
+ * A dialog is exempt. It owns the pointer while it is open, and releasing a
+ * field underneath it re-renders whatever hosts the dialog, which costs the
+ * dialog the focus it just took.
+ */
+const FOCUS_SCOPE_ATTRIBUTE = "data-gloom-focus-scope";
+const DIALOG_CLASS_SELECTOR = ".gloom-dialog";
+
+interface FocusableLike {
+  tagName?: string;
+  isContentEditable?: boolean;
+  blur?: () => void;
+  focus?: () => void;
+  closest?: (selector: string) => { contains?: (node: unknown) => boolean } | null;
+  contains?: (node: unknown) => boolean;
+}
+
+function asFocusable(node: unknown): FocusableLike | null {
+  return node && typeof node === "object" ? node as FocusableLike : null;
+}
+
+export function isEditableTarget(node: unknown): boolean {
+  const element = asFocusable(node);
+  if (!element) return false;
+  if (element.isContentEditable === true) return true;
+  const tag = element.tagName?.toUpperCase();
+  return tag === "INPUT" || tag === "TEXTAREA";
+}
+
+export function shouldReleaseFocus(active: unknown, target: unknown): boolean {
+  if (!isEditableTarget(active) || !target || active === target) return false;
+  if (asFocusable(target)?.closest?.(DIALOG_CLASS_SELECTOR)) return false;
+  const element = asFocusable(active)!;
+  const scope = element.closest?.(`[${FOCUS_SCOPE_ATTRIBUTE}]`) ?? element;
+  return !scope?.contains?.(target);
+}
+
+export function installFocusScopeRelease(): () => void {
+  const doc = (globalThis as { document?: Document }).document;
+  if (!doc) return () => {};
+  const handleMouseDown = (event: MouseEvent) => {
+    const active = doc.activeElement;
+    if (!shouldReleaseFocus(active, event.target)) return;
+    asFocusable(active)?.blur?.();
+  };
+  doc.addEventListener("mousedown", handleMouseDown, true);
+  return () => doc.removeEventListener("mousedown", handleMouseDown, true);
+}

package/src/renderers/electrobun/view/host/input.tsx

@@ -54,11 +54,25 @@ function callTextHandler(handler: unknown, value: string): void {
   }
 }
 
+/**
+ * A press on a field must focus it, even when the owner's controlled flag never
+ * changed. Panes and charts consume their own mousedown, which suppresses the
+ * default focus move, and a field that lost focus externally would otherwise
+ * stay dead until its flag happened to toggle.
+ */
+function focusOnPress(element: HTMLInputElement | HTMLTextAreaElement | null): void {
+  if (!element || document.activeElement === element) return;
+  element.focus();
+}
+
 function applyDomCursorOffset(
   element: HTMLInputElement | HTMLTextAreaElement | null,
   offset: number,
 ) {
-  if (!element) return;
+  // Placing a caret in a field nobody is typing in means nothing, and WebKit
+  // hands the field the focus back when you try, which silently undoes a
+  // release that happened a frame earlier.
+  if (!element || document.activeElement !== element) return;
   const clampedOffset = Math.max(0, Math.min(offset, element.value.length));
   element.setSelectionRange(clampedOffset, clampedOffset);
 }
@@ -262,6 +276,7 @@ export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(fun
       placeholder={getStringProp(props, "placeholder")}
       onInput={(event) => handleValueChange(event.currentTarget.value)}
       onChange={(event) => handleValueChange(event.currentTarget.value)}
+      onMouseDown={() => focusOnPress(elementRef.current)}
       onFocus={() => {
         setDomFocused(true);
         callTextHandler(propsRef.current.onFocus, elementRef.current?.value ?? valueRef.current);

package/src/renderers/electrobun/view/host/mouse.ts

@@ -52,6 +52,7 @@ export function cellMouseEvent(event: MouseLikeEvent, type?: string) {
     pixelX: event.clientX,
     pixelY: event.clientY,
     button: event.button,
+    target: (event as { target?: unknown }).target,
     detail: "detail" in event && typeof event.detail === "number" ? event.detail : 0,
     timeStamp: event.timeStamp,
     modifiers: {

package/src/renderers/electrobun/view/host/style.ts

@@ -103,7 +103,7 @@ export function cleanDomProps(props: Record<string, unknown>): Record<string, un
     "focused", "focusedBackgroundColor", "textColor", "focusedTextColor", "placeholderColor",
     "cursorColor", "selectionBg", "selectionFg", "showCursor", "keyBindings", "wrapText", "wrapMode",
     "initialValue", "value", "onInput", "onChange", "onSubmit", "onEscape", "onCursorChange", "onMouse",
-    "scrollX", "scrollY", "focusable", "bitmap", "bitmaps", "crosshair", "text", "font",
+    "scrollX", "scrollY", "focusable", "bitmap", "bitmaps", "crosshair", "vectors", "text", "font",
     "hoverBackgroundColor",
   ]) {
     delete next[key];

package/src/renderers/electrobun/view/host/tabs.tsx

@@ -27,7 +27,10 @@ export function WebTabs({
   const activeTabRef = useRef<HTMLButtonElement | null>(null);
   const [hoveredValue, setHoveredValue] = useState<string | null>(null);
   const showUnderline = variant === "underline" && !compact;
-  const listHeight = showUnderline ? 28 : compact ? WEB_CELL_HEIGHT : "100%";
+  // A tab bar occupies exactly the one row every caller reserves for it. Any
+  // extra pixels here are pixels the pane's children are told they own and the
+  // pane then clips, which is how a chart's time axis ends up behind a footer.
+  const listHeight = showUnderline || compact ? WEB_CELL_HEIGHT : "100%";
   const tabFontSize = compact || showUnderline ? 12 : 13;
   const tabPaddingInline = dense ? 5 : showUnderline ? 10 : 8;
   const tabPaddingBlock = variant === "bare" || variant === "pill" ? 2 : 0;
@@ -83,7 +86,6 @@ export function WebTabs({
         overflowY: "hidden",
         paddingInline: variant === "underline" || dense ? 0 : 4,
         paddingBlock: tabPaddingBlock,
-        marginBottom: showUnderline ? 4 : 0,
         boxSizing: "border-box",
       }}
     >

package/src/renderers/electrobun/view/main.tsx

@@ -11,6 +11,7 @@ import {
   setElectrobunRemoteRequestHandler,
 } from "./backend-rpc";
 import { installElectrobunAiHost } from "./ai-host";
+import { installFocusScopeRelease } from "./host/focus-scope";
 import { installElectrobunBrokerRemoteClient } from "./broker-remote-client";
 import { installElectrobunConfigStoreHost } from "./config-host";
 import { WebDialogHostProvider } from "./dialog-host";
@@ -88,6 +89,7 @@ async function boot() {
   installElectrobunUpdateHost();
   const init = await measurePerfAsync("startup.electrobun.backend-init", () => backendInitPromise);
   installElectrobunAiHost();
+  installFocusScopeRelease();
   const desktopSnapshot = init.windowKind === "detached" && init.paneId && init.desktopSnapshot
     ? prepareDetachedSnapshot(init.desktopSnapshot, init.paneId)
     : init.desktopSnapshot;

package/src/renderers/opentui/chart-surface.tsx

@@ -96,6 +96,8 @@ export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(functi
   const surfaceId = useRef(`opentui-chart:${nextChartSurfaceId++}`).current;
   const renderableRef = useRef<NativeRenderableNode | null>(null);
   const [target, setTarget] = useState<SurfaceTarget | null>(null);
+  // Only the base layer reaches the terminal: each extra layer would need its own
+  // kitty surface and z-index. Composite overlays into the bitmap you pass here.
   const firstBitmap = Array.isArray(bitmaps) ? bitmaps[0] : null;
   const nativeBitmap = (firstBitmap ?? bitmap ?? null) as NativeChartBitmap | null;
   const nativeCrosshair = (crosshair ?? null) as ChartCrosshairOverlay | null;

package/src/renderers/opentui/host.tsx

@@ -145,6 +145,9 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
           "--profile=sw-fast",
           "--vo=kitty",
           "--vo-kitty-auto-multiplexer-passthrough=yes",
+          "--demuxer-lavf-probe-info=yes",
+          "--demuxer-lavf-analyzeduration=10",
+          "--demuxer-lavf-probesize=25000000",
           "--ytdl=no",
           `--mute=${options?.muted === false ? "no" : "yes"}`,
           ...(title ? [`--title=${title}`] : []),

package/src/sources/gloomberb-cloud/index.test.ts

@@ -339,6 +339,14 @@ describe("GloomberbCloudProvider", () => {
   test("does not advertise unsupported 45 minute chart resolution", () => {
     const provider = new GloomberbCloudProvider();
     expect(provider.getChartResolutionCapabilities()).not.toContain("45m");
+    expect(provider.getChartResolutionSupport()).toContainEqual({
+      resolution: "1d",
+      maxRange: "5Y",
+    });
+    expect(provider.getChartResolutionSupport()).toContainEqual({
+      resolution: "1wk",
+      maxRange: "5Y",
+    });
   });
 
   test("normalizes sub-unit cloud quotes to their main currency", async () => {

package/src/sources/gloomberb-cloud/index.ts

@@ -29,7 +29,7 @@ import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
 import { canonicalTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory } from "../../utils/price-history";
 import { createProviderMiss } from "../provider-errors";
-import { hasMalformedCloudIntradayHistory } from "./history-quality";
+import { hasMalformedIntradayHistory } from "../../time-series/history-quality";
 import {
   cloudNewsParams,
   mapCloudNewsArticle,
@@ -55,8 +55,8 @@ const CLOUD_RESOLUTION_SUPPORT = normalizeChartResolutionSupport([
   { resolution: "15m", maxRange: "3M" },
   { resolution: "30m", maxRange: "6M" },
   { resolution: "1h", maxRange: "1Y" },
-  { resolution: "1d", maxRange: "ALL" },
-  { resolution: "1wk", maxRange: "ALL" },
+  { resolution: "1d", maxRange: "5Y" },
+  { resolution: "1wk", maxRange: "5Y" },
   { resolution: "1mo", maxRange: "ALL" },
 ]);
 const CLOUD_PROVIDER_MISS_PATTERNS = [
@@ -113,7 +113,7 @@ function mapCloudPriceHistory(
   if (
     /(min|h)$/i.test(interval)
     && upstream !== "yahoo"
-    && hasMalformedCloudIntradayHistory(points)
+    && hasMalformedIntradayHistory(points)
   ) {
     throw createProviderMiss(`Cloud chart data failed OHLC validation for ${ticker}`);
   }

package/src/sources/provider-router/history.test.ts

@@ -146,7 +146,7 @@ describe("AssetDataRouter chart history", () => {
         namespace: "market",
         kind: "price-history",
         entityKey: "META",
-        variantKey: "exchange=NASDAQ;range=1M;resolution=5m;version=2",
+        variantKey: "exchange=NASDAQ;range=1M;resolution=5m;version=3",
         sourceKey: "provider:gloomberb-cloud",
       },
       [
@@ -181,8 +181,8 @@ describe("AssetDataRouter chart history", () => {
       .query("SELECT variant_key FROM resource_cache WHERE namespace = ? AND kind = ? AND entity_key = ? ORDER BY variant_key")
       .all("market", "price-history", "META") as Array<{ variant_key: string }>;
     expect(cachedRows.map((row) => row.variant_key)).toEqual([
-      "exchange=NASDAQ;range=1M;resolution=5m;version=2",
       "exchange=NASDAQ;range=1M;resolution=5m;version=3",
+      "exchange=NASDAQ;range=1M;resolution=5m;version=4",
     ]);
 
     persistence.close();
@@ -233,7 +233,7 @@ describe("AssetDataRouter chart history", () => {
       .all("market", "price-history", "FTC") as Array<{ variant_key: string }>;
     expect(cachedRows.map((row) => row.variant_key)).toEqual([
       "exchange=LSE;range=ALL;resolution=1wk",
-      "exchange=LSE;range=ALL;resolution=1wk;version=3;unit=GBP",
+      "exchange=LSE;range=ALL;resolution=1wk;version=4;unit=GBP",
     ]);
 
     persistence.close();