gloomberb 0.13.2 → 0.14.0

package/src/renderers/opentui/test-utils.tsx

@@ -1,13 +1,60 @@
-import { useMemo, type ReactNode } from "react";
-import { testRender as openTuiTestRender } from "@opentui/react/test-utils";
 import { createRoot as openTuiCreateRoot, useRenderer } from "@opentui/react";
+import { testRender as openTuiTestRender } from "@opentui/react/test-utils";
+import { act, useMemo, type ReactNode } from "react";
+import { setMarketDataNotifyThrottle } from "../../market-data/coordinator/events";
+import { colors } from "../../theme/colors";
+
+// Pane tests emit a quote, await one timer tick, and assert the frame. The
+// production pacing of coordinator notifications would put the second tick
+// of a test 100ms out; the events unit test covers the pacing itself.
+setMarketDataNotifyThrottle(0);
 import { UiHostProvider, type NativeRendererHost, type RendererHost } from "../../ui";
 import { ToastHostProvider } from "../../ui/toast";
-import { colors } from "../../theme/colors";
-import { OpenTuiInputHostProvider } from "./input-host";
-import { openTuiUiHost } from "./ui-host";
 import { OpenTuiDialogHostProvider } from "./dialog-host";
+import { OpenTuiInputHostProvider } from "./input-host";
 import { openTuiToastHost } from "./toast-host";
+import { openTuiUiHost } from "./ui-host";
+
+export interface TestKeyEvent {
+  name?: string;
+  sequence?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  shift?: boolean;
+  alt?: boolean;
+  option?: boolean;
+  defaultPrevented?: boolean;
+  propagationStopped?: boolean;
+}
+
+/** Batch keys in one React update; keep each suite's frame and propagation semantics. */
+export async function emitKeypress(
+  setup: Awaited<ReturnType<typeof testRender>>,
+  events: TestKeyEvent | TestKeyEvent[],
+  { frames = 1, afterCommit = false, trackPropagation = false } = {},
+) {
+  let lastEvent;
+  await act(async () => {
+    for (const event of Array.isArray(events) ? events : [events]) {
+      let defaultPrevented = event.defaultPrevented === true;
+      let propagationStopped = event.propagationStopped === true;
+      lastEvent = {
+        ctrl: false, alt: false, meta: false, option: false, shift: false,
+        eventType: "press", repeated: false,
+        ...event,
+        get defaultPrevented() { return defaultPrevented; },
+        get propagationStopped() { return propagationStopped; },
+        preventDefault() { if (trackPropagation) defaultPrevented = true; },
+        stopPropagation() { if (trackPropagation) propagationStopped = true; },
+      };
+      setup.renderer.keyInput.emit("keypress", lastEvent as any);
+    }
+    for (let index = 0; index < frames; index++) await setup.renderOnce();
+  });
+  if (afterCommit) await setup.renderOnce();
+  return lastEvent!;
+}
 
 let lastSavedTextFile: { name: string; text: string } | null = null;
 
@@ -91,7 +138,7 @@ export function testRender(
   node: ReactNode,
   options?: Parameters<typeof openTuiTestRender>[1],
 ): ReturnType<typeof openTuiTestRender> {
-  return openTuiTestRender(withOpenTuiTestProviders(node), options);
+  return openTuiTestRender(withOpenTuiTestProviders(node), options ?? {});
 }
 
 export function createOpenTuiTestRoot(
@@ -108,3 +155,67 @@ export function createOpenTuiTestRoot(
     },
   });
 }
+
+/**
+ * Advances one polling step: sleeps, then renders. Both happen inside `act` so
+ * that anything a resolving promise queued during the sleep is flushed before
+ * the next frame is captured. Polling outside `act` leaves the update to
+ * React's scheduler, which is why a loaded CI box could time out waiting for a
+ * frame the app had already produced.
+ */
+export async function settleFrame(
+  renderer: Awaited<ReturnType<typeof testRender>>,
+  delayMs = 50,
+): Promise<void> {
+  await act(async () => {
+    await Bun.sleep(delayMs);
+  });
+  // Paint after React has committed the updates collected by act.
+  await renderer.renderOnce();
+}
+
+export function createTestControls(
+  getRenderer: () => Awaited<ReturnType<typeof testRender>>,
+) {
+  const waitForFrameToContain = async (text: string, attempts = 12, delayMs = 50): Promise<string> => {
+    const renderer = getRenderer();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const frame = renderer.captureCharFrame();
+      if (frame.includes(text)) {
+        return frame;
+      }
+      await settleFrame(renderer, delayMs);
+    }
+    throw new Error(`Timed out waiting for frame to contain "${text}".\n${renderer.captureCharFrame()}`);
+  };
+
+  const clickFrameText = async (text: string): Promise<void> => {
+    const renderer = getRenderer();
+    const frame = renderer.captureCharFrame();
+    const rows = frame.split("\n");
+    const row = rows.findIndex((line) => line.includes(text));
+    const col = row >= 0 ? rows[row]!.indexOf(text) : -1;
+
+    if (row < 0 || col < 0) throw new Error(`No frame text "${text}".\n${frame}`);
+
+    await act(async () => {
+      await renderer.mockMouse.click(col + 1, row);
+      await renderer.renderOnce();
+    });
+  };
+
+  const renderFrames = async (count = 2): Promise<void> => {
+    const renderer = getRenderer();
+    for (let index = 0; index < count; index += 1) {
+      await act(async () => {
+        await renderer.renderOnce();
+      });
+    }
+  };
+
+  return {
+    waitForFrameToContain,
+    clickFrameText,
+    renderFrames,
+  };
+}

package/src/renderers/opentui/ui-host.tsx

@@ -123,7 +123,7 @@ export const openTuiUiHost: UiHost = {
   ImageSurface: OpenTuiImageSurface,
   MediaSurface: OpenTuiMediaSurface as UiHost["MediaSurface"],
   SpinnerMark: OpenTuiSpinnerMark as UiHost["SpinnerMark"],
-  AsciiText: ({ text, font = "tiny", color, fg, bg, backgroundColor, selectable = false, ...props }) => {
+  AsciiText: ({ text, font = "tiny", color, fg, bg, backgroundColor, selectable = false, scale: _scale, ...props }) => {
     const resolvedColor = color ?? fg;
     const resolvedBackground = backgroundColor ?? bg;
     if (font === "wordmark") {

package/src/renderers/share/chart.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { sharedChartGeometry } from "./chart";
+
+describe("shared chart coordinates", () => {
+  test("aligns unequal and irregular histories by their timestamps, including singleton series", () => {
+    const result = sharedChartGeometry({ title: "Common dates", series: [
+      { name: "Long", unit: "%", points: [{ x: "2026-01-01", y: 0 }, { x: "2026-01-10", y: 10 }, { x: "2026-01-11", y: 11 }] },
+      { name: "Short", unit: "%", points: [{ x: "2026-01-10", y: 5 }, { x: "2026-01-11", y: 6 }] },
+      { name: "Single", unit: "%", points: [{ x: "2026-01-10", y: 8 }] },
+    ] });
+    const [long, short, single] = result.panels[0]!.series;
+    expect(long!.segments[0]!.map((point) => point.x)).toEqual([20, 884, 980]);
+    expect(short!.segments[0]![0]!.x).toBe(884);
+    expect(single!.segments[0]![0]!.x).toBe(884);
+    expect(result.startLabel).toBe("2026-01-01");
+    expect(result.endLabel).toBe("2026-01-11");
+  });
+
+  test("keeps gaps, incompatible units and a requested date window", () => {
+    const result = sharedChartGeometry({ title: "Units", viewport: { start: "2026-01-01", end: "2026-01-11" }, series: [
+      { name: "Price", unit: "USD", points: [{ x: "2026-01-02", y: 100 }, { x: "2026-01-03", y: null }, { x: "2026-01-04", y: 110 }] },
+      { name: "Return", unit: "%", points: [{ x: "2026-01-04", y: 1 }] },
+    ] });
+    expect(result.panels.map((panel) => panel.unit)).toEqual(["USD", "%"]);
+    expect(result.panels[0]!.series[0]!.segments).toHaveLength(2);
+    expect(result.panels[0]!.min).toBe(100);
+    expect(result.panels[0]!.max).toBe(110);
+    expect(result.panels[1]!.series[0]!.segments[0]![0]!.x).toBe(308);
+  });
+
+  test("uses common numeric and categorical axes for existing share formats", () => {
+    for (const inputs of [[1, 10, 11], ["one", "ten", "eleven"]] as const) {
+      const result = sharedChartGeometry({ title: "Legacy", series: [
+        { name: "A", points: inputs.map((x, y) => ({ x, y })) },
+        { name: "B", points: [{ x: inputs[1], y: 1 }] },
+      ] });
+      expect(result.panels[0]!.series[1]!.segments[0]![0]!.x).toBe(result.panels[0]!.series[0]!.segments[0]![1]!.x);
+      expect(result.panels[0]!.unit).toBe("Unit unavailable");
+    }
+  });
+});
+
+test("shared steps retain level changes and empty panels have no numerical evidence", async () => {
+  const { sharedChartLinePoints } = await import("./chart");
+  const result = sharedChartGeometry({ title: "Known and unknown", series: [
+    { name: "Rate", unit: "%", style: "step", points: [{ x: 1, y: 2 }, { x: 2, y: 3 }] },
+    { name: "Unavailable price", unit: "USD", points: [{ x: 1, y: null }] },
+  ] });
+  expect(result.panels[0]!.hasValues).toBe(true);
+  expect(sharedChartLinePoints(result.panels[0]!.series[0]!.segments[0]!, "step")).toBe("20,300 980,300 980,20");
+  expect(result.panels[1]!.hasValues).toBe(false);
+});

package/src/renderers/share/chart.ts

@@ -0,0 +1,74 @@
+import type { ChartShareData } from "../../shares/payload";
+
+export interface SharedChartMark { x: number; y: number; label: string }
+export interface SharedChartPanel {
+  unit: string;
+  hasValues: boolean;
+  min: number;
+  max: number;
+  series: Array<{ name: string; index: number; style: "line" | "step" | "points"; segments: SharedChartMark[][] }>;
+}
+
+/** Shared coordinates are data coordinates, never independent row indices. */
+export function sharedChartGeometry(data: ChartShareData) {
+  const labels = data.series.flatMap((entry) => entry.points.map((point) => point.x));
+  const dates = labels.every((value) => typeof value === "string" && /^\d{4}-\d{2}-\d{2}(?:T.*)?$/.test(value)
+    && Number.isFinite(Date.parse(value)));
+  const numeric = labels.every((value) => typeof value === "number");
+  const categories = [...new Set(labels.map((value) => `${typeof value}:${value}`))];
+  const position = (value: string | number) => dates ? Date.parse(String(value)) : numeric ? Number(value)
+    : categories.indexOf(`${typeof value}:${value}`);
+  const positions = labels.map(position);
+  let start = Math.min(...positions);
+  let end = Math.max(...positions);
+  if (dates && data.viewport) { start = Date.parse(data.viewport.start); end = Date.parse(data.viewport.end); }
+  const x = (value: string | number) => start === end ? 500 : 20 + (position(value) - start) / (end - start) * 960;
+  const groups = new Map<string, Array<{ entry: ChartShareData["series"][number]; index: number }>>();
+  data.series.forEach((entry, index) => {
+    const unit = entry.unit || "Unit unavailable";
+    groups.set(unit, [...(groups.get(unit) ?? []), { entry, index }]);
+  });
+  const scopedPoints = (entry: ChartShareData["series"][number]) => {
+    const ordered = [...entry.points].sort((a, b) => position(a.x) - position(b.x));
+    const anchor = entry.style === "step" && !ordered.some((point) => position(point.x) === start)
+      ? ordered.findLast((point) => position(point.x) < start) : undefined;
+    return ordered.filter((point) => point === anchor || (position(point.x) >= start && position(point.x) <= end));
+  };
+  const panels: SharedChartPanel[] = [...groups].map(([unit, entries]) => {
+    const values = entries.flatMap(({ entry }) => scopedPoints(entry)
+      .flatMap((point) => point.y === null ? [] : [point.y]));
+    let min = values.length ? Math.min(...values) : 0;
+    let max = values.length ? Math.max(...values) : 1;
+    if (min === max) { const pad = Math.abs(min) * 0.05 || 1; min -= pad; max += pad; }
+    return { unit, hasValues: values.length > 0, min, max, series: entries.map(({ entry, index }) => {
+      const segments: SharedChartMark[][] = [];
+      let current: SharedChartMark[] = [];
+      for (const point of scopedPoints(entry)) {
+        if (point.y === null) {
+          if (current.length) segments.push(current);
+          current = [];
+          continue;
+        }
+        current.push({ x: Math.max(20, x(point.x)), y: 300 - (point.y - min) / (max - min) * 280,
+          label: `${point.x}: ${point.y} ${entry.unit ?? "(unit unavailable)"}` });
+      }
+      if (entry.style === "step" && current.length && current.at(-1)!.x < 980 && end > start) {
+        const last = current.at(-1)!;
+        current.push({ ...last, x: 980, label: `Held level from ${last.label}` });
+      }
+      if (current.length) segments.push(current);
+      return { name: entry.name, index, style: entry.style ?? "line", segments };
+    }) };
+  });
+  const dateLabel = (time: number) => new Date(time).toISOString().replace("T", " ").slice(0, end - start <= 2 * 86400000 ? 16 : 10);
+  return { panels, startLabel: dates ? dateLabel(start) : String(numeric ? start : labels.find((value) => position(value) === start)),
+    endLabel: dates ? dateLabel(end) : String(numeric ? end : labels.find((value) => position(value) === end)),
+    axisLabel: dates ? "Time (UTC)" : numeric ? "X value" : "Category" };
+}
+
+/** Expand step-after observations without inventing intermediate values. */
+export function sharedChartLinePoints(segment: SharedChartMark[], style: "line" | "step" | "points"): string {
+  return segment.flatMap((point, index) => style === "step" && index > 0
+    ? [`${point.x},${segment[index - 1]!.y}`, `${point.x},${point.y}`]
+    : [`${point.x},${point.y}`]).join(" ");
+}

package/src/renderers/share/main.tsx

@@ -52,8 +52,16 @@ function ContentShareApp({ id }: { id: string }) {
   }>({});
   useEffect(() => {
     const controller = new AbortController();
-    getShare(id, (url, init) => fetch(url, { ...init, signal: controller.signal }))
-      .then((share) => setState(share ? { share } : { error: "This share is unavailable or has expired." }))
+    getShare(id, (url, init) => fetch(url, { ...init, signal: controller.signal }), { trackView: false })
+      .then((share) => {
+        if (share?.kind === "pane") {
+          // A pane share is a live hand-off: the hosted terminal opens on the
+          // shared pane. Nothing here needs to render first.
+          window.location.replace(openLiveShareUrl(id));
+          return;
+        }
+        setState(share ? { share } : { error: "This share is unavailable or has expired." });
+      })
       .catch(() => { if (!controller.signal.aborted) setState({ error: "This share could not be loaded." }); });
     return () => controller.abort();
   }, [id]);

package/src/renderers/share/styles.css

@@ -52,3 +52,32 @@ main.pane h1 { margin-bottom: 14px; overflow-wrap: anywhere; }
   .layout-pane { padding: 7px; font-size: 12px; }
   .layout-extra-panes { right: 10px; bottom: 10px; width: 52%; }
 }
+.snapshot-date, .chart-notes { color: #b8bbc5; font-size: 12px; }
+.chart-panel { margin: 28px 0; }
+.chart-dates { display: flex; justify-content: space-between; gap: 12px; font-size: 12px; }
+.chart-unit { display: block; margin-bottom: 8px; font-size: 12px; }
+.chart-plot { display: flex; height: 300px; }
+.chart-plot .chart { flex: 1; min-width: 0; height: 100%; }
+.chart-y-axis { display: flex; flex-direction: column; justify-content: space-between; padding: 18px 8px 18px 0; width: 76px; flex-shrink: 0; text-align: right; font-size: 12px; line-height: 1; }
+.chart-dates { margin-top: 8px; margin-left: 84px; }
+.chart-grid { stroke: #4a4e5c; stroke-width: 0.5; vector-effect: non-scaling-stroke; }
+.series-point { fill: #f1b94a; stroke-width: 4; vector-effect: non-scaling-stroke; }
+.series-point.series-0 { stroke: #f1b94a; }
+.series-point.series-1 { fill: #62b8f6; } .series-point.series-2 { fill: #7fd18a; } .series-point.series-3 { fill: #ef7f7f; } .series-point.series-4 { fill: #b697ef; } .series-point.series-5 { fill: #e29b63; }
+.series-key { display: inline-block; width: 14px; margin-right: 6px; border-top: 2px solid #f1b94a; vertical-align: middle; }
+.series-key.series-1 { border-color: #62b8f6; } .series-key.series-2 { border-color: #7fd18a; } .series-key.series-3 { border-color: #ef7f7f; } .series-key.series-4 { border-color: #b697ef; } .series-key.series-5 { border-color: #e29b63; }
+.shared-data summary { cursor: pointer; padding: 10px 0; }
+.shared-data caption { text-align: left; padding: 10px; }
+.shared-data .table-wrap { max-height: 360px; margin-top: 12px; }
+@media (max-width: 640px) {
+  .chart-dates { flex-wrap: wrap; }
+  .chart-dates span:nth-child(2) { order: 3; flex-basis: 100%; text-align: center; }
+  .chart-plot { height: 200px; }
+  .chart-y-axis { width: 64px; padding-top: 12px; padding-bottom: 12px; }
+  .chart-dates { margin-left: 72px; }
+  .legend { font-size: 12px; }
+}
+
+main.wide h1, .legend li, .chart-notes li, .shared-data caption { overflow-wrap: anywhere; }
+.chart-unavailable { color: #b8bbc5; border: 1px solid #4a4e5c; padding: 20px; }
+.chart-y-axis { font-variant-numeric: tabular-nums; }

package/src/renderers/share/view.test.tsx

@@ -98,3 +98,23 @@ test("pane share renders the handoff copy, tracked CTA and printable facts only"
   expect(html).not.toContain("<script>");
   expect(html).toContain("Delete share");
 });
+
+test("chart snapshot retains exact values, gaps and units without a fabricated empty-panel scale", () => {
+  const html = renderToStaticMarkup(<ShareView share={{
+    kind: "chart",
+    data: { title: "Research snapshot", series: [
+      { name: "Price", unit: "USD", points: [{ x: "2026-01-01", y: 123.456789 }, { x: "2026-01-02", y: null }, { x: "2026-01-03", y: 124 }] },
+      { name: "Missing yield", unit: "%", points: [{ x: "2026-01-01", y: null }] },
+    ], warnings: ["Partial history"] },
+    createdAt: "2026-09-10T12:00:00Z", expiresAt: "2026-10-10T12:00:00Z", ownedByViewer: false,
+  }} />);
+  expect(html).toContain("123.456789");
+  expect(html).toContain("Unavailable");
+  expect(html).toContain("Partial history");
+  expect(html).toContain("Snapshot shared 2026-09-10 12:00 UTC");
+  expect(html.match(/<circle/g)).toHaveLength(2);
+  expect(html).not.toContain("<polyline");
+  const emptyPanel = html.slice(html.indexOf('aria-label="% chart"'), html.indexOf('class="chart-notes"'));
+  expect(emptyPanel).toContain("No observations available");
+  expect(emptyPanel).not.toContain("chart-y-axis");
+});

package/src/renderers/share/view.tsx

@@ -1,5 +1,6 @@
 /** @jsxImportSource react */
 import type { ShareRecord } from "../../shares/api";
+import { sharedChartGeometry, sharedChartLinePoints } from "./chart";
 
 const FACT_LIMIT = 8;
 const FACT_MAX_LENGTH = 120;
@@ -125,24 +126,32 @@ export function ShareView({
       </main>
     );
   }
-  const values = share.data.series.flatMap((series) => series.points.map((point) => point.y));
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  const span = max - min || 1;
+  const chart = sharedChartGeometry(share.data);
+  const format = (value: number) => value.toLocaleString("en-US", { maximumSignificantDigits: 6 });
   return (
     <main className="wide">
       <h1>{share.data.title}</h1>
-      <svg className="chart" viewBox="0 0 1000 420" role="img" aria-label={share.data.title}>
-        {share.data.series.map((series, seriesIndex) => {
-          const points = series.points.map((point, index) => {
-            const x = series.points.length <= 1 ? 500 : 20 + (index / (series.points.length - 1)) * 960;
-            const y = 400 - ((point.y - min) / span) * 380;
-            return `${x},${y}`;
-          }).join(" ");
-          return <polyline key={series.name} points={points} className={`series series-${seriesIndex % 6}`} />;
-        })}
-      </svg>
-      <ul className="legend">{share.data.series.map((series) => <li key={series.name}>{series.name}</li>)}</ul>
+      <p className="snapshot-date">Snapshot shared {new Date(share.createdAt).toISOString().replace("T", " ").slice(0, 16)} UTC. Observation dates appear below.</p>
+      {chart.panels.map((panel) => <section className="chart-panel" key={panel.unit} aria-label={`${panel.unit} chart`}>
+        <strong className="chart-unit">{panel.unit}</strong>
+        {panel.hasValues ? <><div className="chart-plot"><div className="chart-y-axis"><span>{format(panel.max)}</span><span>{format((panel.max + panel.min) / 2)}</span><span>{format(panel.min)}</span></div>
+        <svg className="chart" viewBox="0 0 1000 320" preserveAspectRatio="none" role="img" aria-label={`${share.data.title} — ${panel.unit}`}>
+          <line x1="20" x2="980" y1="160" y2="160" className="chart-grid" />
+          {panel.series.flatMap((series) => series.segments.map((segment, segmentIndex) => segment.length === 1 || series.style === "points"
+            ? segment.map((point, pointIndex) => <circle key={`${series.index}:${segmentIndex}:${pointIndex}`} cx={point.x} cy={point.y} r="1" className={`series-point series-${series.index % 6}`}><title>{`${series.name}: ${point.label}`}</title></circle>)
+            : <polyline key={`${series.index}:${segmentIndex}`} points={sharedChartLinePoints(segment, series.style)} className={`series series-${series.index % 6}`}><title>{series.name}</title></polyline>))}
+        </svg></div>
+        <div className="chart-dates"><span>{chart.startLabel}</span><span>{chart.axisLabel}</span><span>{chart.endLabel}</span></div></> : <p className="chart-unavailable">No observations available in this window.</p>}
+        <ul className="legend">{panel.series.map((series) => <li key={series.index}><span className={`series-key series-${series.index % 6}`} />{series.name}</li>)}</ul>
+      </section>)}
+      {share.data.warnings?.length ? <ul className="chart-notes">{share.data.warnings.map((warning, index) => <li key={index}>{warning}</li>)}</ul> : null}
+      <details className="shared-data"><summary>View snapshot data</summary>
+        {share.data.series.map((series, index) => <div className="table-wrap" key={index}><table>
+          <caption>{series.name} · {series.unit ?? "Unit unavailable"}</caption>
+          <thead><tr><th>{chart.axisLabel}</th><th>Value</th></tr></thead>
+          <tbody>{series.points.map((point, pointIndex) => <tr key={pointIndex}><td>{point.x}</td><td>{point.y === null ? "Unavailable" : String(point.y)}</td></tr>)}</tbody>
+        </table></div>)}
+      </details>
       <SourceLink url={share.data.sourceUrl} />
       {ownerActions}
     </main>

package/src/shares/api.test.ts

@@ -24,6 +24,21 @@ const portablePane = {
 const shareId = "0123456789abcdef0123456789abcdef";
 
 describe("share API client", () => {
+  test("chart viewport dates require real calendar dates and explicit timestamp zones", () => {
+    const payload = (start: string, end = start) => ({ kind: "chart", data: {
+      title: "Window", viewport: { start, end }, series: [{ name: "A", points: [{ x: start, y: 1 }] }],
+    } });
+    for (const date of ["2024-02-29", "2000-02-29", "2026-09-10T12:30Z", "2026-09-10T12:30:45.123+02:00"]) {
+      expect(parseSharePayload(payload(date))).not.toBeNull();
+    }
+    for (const date of ["2026-02-30", "2026-02-29", "1900-02-29", "2026-04-31", "2026-00-01", "2026-01-00",
+      "09/10/2026", "2026-9-1", "2026-09-10T12:30:00", "2026-02-30T12:00:00Z", "2026-09-10T24:00:00Z",
+      "2026-09-10T12:60:00Z", "2026-09-10T12:30:60Z", "2026-09-10T12:30:00+24:00", "2026-09-10T12:30:00+02:60"]) {
+      expect(parseSharePayload(payload(date))).toBeNull();
+    }
+    expect(parseSharePayload(payload("2026-09-10T03:00:00+02:00", "2026-09-10T00:30:00Z"))).toBeNull();
+  });
+
   test("validates strict payloads and http(s)-only source URLs", () => {
     expect(parseSharePayload(article)).toEqual(article);
     expect(parseSharePayload({ ...article, data: { ...article.data, sourceUrl: "javascript:alert(1)" } })).toBeNull();

package/src/shares/live.ts

@@ -0,0 +1,27 @@
+import type { AppNotificationRequest } from "../types/plugin";
+import { createShare, openLiveShareUrl } from "./api";
+import type { SharePayload } from "./payload";
+
+/**
+ * Every share is a live hand-off: the link opens the hosted terminal on the
+ * same pane the sender is looking at. One implementation, so the shell
+ * shortcut, the pane menu, and pane-level share hints cannot drift apart.
+ */
+export async function copyLivePaneShare(
+  payload: Extract<SharePayload, { kind: "pane" }>,
+  host: {
+    copyText: (text: string) => Promise<void> | void;
+    notify: (notification: AppNotificationRequest) => void;
+  },
+): Promise<void> {
+  try {
+    const { id } = await createShare(payload);
+    await host.copyText(openLiveShareUrl(id));
+    host.notify({ body: "Share link copied to clipboard", type: "success" });
+  } catch (error) {
+    host.notify({
+      body: error instanceof Error ? error.message : "Could not share this pane.",
+      type: "error",
+    });
+  }
+}

package/src/shares/pane.ts

@@ -3,6 +3,7 @@ import {
 } from "../layout-marketplace/payload";
 import type { PluginRegistry } from "../plugins/registry";
 import type { PaneInstanceConfig } from "../types/config";
+import type { TickerRecord } from "../types/ticker";
 import { parseSharePayload, type PaneShareData, type SharePayload } from "./payload";
 
 export function buildPaneSharePayload(
@@ -10,6 +11,7 @@ export function buildPaneSharePayload(
   pane: PaneInstanceConfig,
   paneState: Record<string, unknown> = {},
   resolvedTicker?: string | null,
+  tickers?: ReadonlyMap<string, TickerRecord>,
 ): Extract<SharePayload, { kind: "pane" }> | null {
   const def = pluginRegistry.panes.get(pane.paneId);
   if (!def) return null;
@@ -19,6 +21,7 @@ export function buildPaneSharePayload(
       paneState,
       pluginRegistry.panes,
       resolvedTicker,
+      { tickers },
     );
     const instance = layout.layout.instances[0]!;
     const description = [...pluginRegistry.paneTemplates.values()]

package/src/shares/payload.ts

@@ -32,8 +32,12 @@ export interface ChartShareData {
   title: string;
   series: Array<{
     name: string;
-    points: Array<{ x: string | number; y: number }>;
+    unit?: string;
+    style?: "line" | "step" | "points";
+    points: Array<{ x: string | number; y: number | null }>;
   }>;
+  viewport?: { start: string; end: string };
+  warnings?: string[];
   sourceUrl?: string;
 }
 
@@ -78,6 +82,24 @@ function safeOptionalUrl(value: unknown): value is string | undefined {
   return value === undefined || (typeof value === "string" && safeExternalUrl(value) !== null);
 }
 
+function viewportDate(value: unknown): value is string {
+  if (typeof value !== "string" || value.length > 40) return false;
+  const match = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2}))?$/.exec(value);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (month < 1 || month > 12 || day < 1 || day > days[month - 1]!) return false;
+  if (match[4] !== undefined) {
+    if (Number(match[4]) > 23 || Number(match[5]) > 59 || Number(match[6] ?? 0) > 59) return false;
+    const zone = match[7]!;
+    if (zone !== "Z" && (Number(zone.slice(1, 3)) > 23 || Number(zone.slice(4, 6)) > 59)) return false;
+  }
+  return Number.isFinite(Date.parse(value));
+}
+
 function isCell(value: unknown): value is CellValue {
   return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
@@ -99,18 +121,28 @@ function isTableData(value: unknown): value is TableShareData {
 
 function isChartData(value: unknown): value is ChartShareData {
   if (!record(value) || !shortString(value.title) || !safeOptionalUrl(value.sourceUrl)) return false;
+  if (Object.keys(value).some((key) => !["title", "series", "sourceUrl", "viewport", "warnings"].includes(key))) return false;
+  if (value.warnings !== undefined && (!Array.isArray(value.warnings) || value.warnings.length > 20
+    || !value.warnings.every((warning) => shortString(warning, 500)))) return false;
+  if (value.viewport !== undefined && (!record(value.viewport)
+    || Object.keys(value.viewport).some((key) => !["start", "end"].includes(key))
+    || !viewportDate(value.viewport.start) || !viewportDate(value.viewport.end)
+    || Date.parse(value.viewport.start) > Date.parse(value.viewport.end))) return false;
   return Array.isArray(value.series)
     && value.series.length > 0
     && value.series.length <= MAX_CHART_SERIES
     && value.series.every((series) => record(series)
+      && Object.keys(series).every((key) => ["name", "points", "unit", "style"].includes(key))
       && shortString(series.name, 120)
+      && (series.unit === undefined || shortString(series.unit, 80))
+      && (series.style === undefined || ["line", "step", "points"].includes(series.style as string))
       && Array.isArray(series.points)
       && series.points.length > 0
       && series.points.length <= MAX_CHART_POINTS
       && series.points.every((point) => record(point)
+        && Object.keys(point).every((key) => ["x", "y"].includes(key))
         && ((typeof point.x === "string" && point.x.length <= 100) || (typeof point.x === "number" && Number.isFinite(point.x)))
-        && typeof point.y === "number"
-        && Number.isFinite(point.y)));
+        && (point.y === null || (typeof point.y === "number" && Number.isFinite(point.y)))));
 }
 
 function isArticleData(value: unknown): value is ArticleShareData {