gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/custom-view/index.tsx

@@ -0,0 +1,69 @@
+import type { GloomPlugin, PaneTemplateCreateOptions } from "../../../types/plugin";
+import { CUSTOM_VIEW_PANE_ID, CUSTOM_VIEW_SPEC_SETTING, CustomViewPane } from "./pane";
+import { parseViewSpec, serializeViewSpec, type ViewSpec } from "./view-spec";
+
+export { CUSTOM_VIEW_PANE_ID, CUSTOM_VIEW_SPEC_SETTING } from "./pane";
+export { setViewRefResolver } from "./loader";
+export * from "./view-spec";
+
+export const CUSTOM_VIEW_TEMPLATE_ID = "custom-view-pane";
+
+/** The pane instance settings for a spec, the one place that shape is decided. */
+export function customViewInstanceSettings(spec: ViewSpec): Record<string, string> {
+  return { [CUSTOM_VIEW_SPEC_SETTING]: serializeViewSpec(spec) };
+}
+
+export function customViewCreateOptions(spec: ViewSpec, name?: string): PaneTemplateCreateOptions {
+  const title = name?.trim() || spec.presentation.title;
+  return { values: { spec: serializeViewSpec(spec), ...(title ? { title } : {}) } };
+}
+
+/**
+ * Custom views: declarative tables built by ASKG or the local agent through
+ * view.create and view.update, rendered by one built-in pane, and publishable
+ * to a team where they become pane templates for every member.
+ */
+export const customViewPlugin: GloomPlugin = {
+  id: "custom-view",
+  name: "Custom Views",
+  version: "1.0.0",
+  description: "Tables built from any data function: columns, a filter, a sort. Made by the agent, shared with a team.",
+  toggleable: false,
+
+  panes: [{
+    id: CUSTOM_VIEW_PANE_ID,
+    name: "View",
+    icon: "V",
+    component: CustomViewPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 100, height: 28 },
+    tableExport: true,
+    settings: {
+      fields: [{
+        key: CUSTOM_VIEW_SPEC_SETTING,
+        label: "View spec (JSON)",
+        type: "text",
+        description: "Source, columns, filters, sort. Ask Gloom to write it.",
+      }],
+    },
+  }],
+
+  paneTemplates: [{
+    id: CUSTOM_VIEW_TEMPLATE_ID,
+    paneId: CUSTOM_VIEW_PANE_ID,
+    label: "Custom View",
+    description: "A table from any data function with your columns, filter, and sort.",
+    keywords: ["view", "custom", "table", "query", "screen", "columns", "filter"],
+    shortcut: { prefix: "VIEW", argPlaceholder: "spec JSON or empty", argKind: "text" },
+    createInstance: (_context, options) => {
+      const raw = options?.values?.spec ?? options?.arg ?? "";
+      const spec = raw ? parseViewSpec(raw) : null;
+      return {
+        placement: "floating",
+        ...(options?.values?.title ? { title: options.values.title } : spec?.presentation.title ? { title: spec.presentation.title } : {}),
+        ...(spec ? { settings: customViewInstanceSettings(spec) } : {}),
+      };
+    },
+  }],
+};

package/src/plugins/builtin/custom-view/loader.ts

@@ -0,0 +1,107 @@
+import type { HeadlessPaneColumn } from "../../../types/headless";
+import { loadResolvedHeadlessPaneModel, serializeHeadlessPaneResult } from "../../../cli/pane-functions/headless";
+import { resolvePaneFunction } from "../../../cli/pane-functions/resolver";
+import type { AppConfig } from "../../../types/config";
+import { getSharedRegistry } from "../../registry";
+import { marketContextFromRegistry } from "../cloud/askg/host";
+import type { ViewRow, ViewSource, ViewSpec } from "./view-spec";
+
+export interface LoadedView {
+  rows: ViewRow[];
+  columns: HeadlessPaneColumn[];
+  errors: string[];
+  sourceLabel: string;
+}
+
+/** Turns a `ref` source into its inline spec; installed by the cloud views module. */
+export type ViewRefResolver = (source: Extract<ViewSource, { kind: "ref" }>) => Promise<ViewSpec | null>;
+
+let refResolver: ViewRefResolver | null = null;
+
+export function setViewRefResolver(resolver: ViewRefResolver | null): void {
+  refResolver = resolver;
+}
+
+function rowsFromResult(result: Record<string, unknown>): { rows: ViewRow[]; columns: HeadlessPaneColumn[] } {
+  if (Array.isArray(result.rows)) {
+    return { rows: result.rows as ViewRow[], columns: (result.columns as HeadlessPaneColumn[] | undefined) ?? [] };
+  }
+  if (Array.isArray(result.items)) {
+    return { rows: result.items as ViewRow[], columns: (result.columns as HeadlessPaneColumn[] | undefined) ?? [] };
+  }
+  if (Array.isArray(result.sections)) {
+    // A bundle flattens into one table with a section column.
+    const rows: ViewRow[] = [];
+    const columns = new Map<string, HeadlessPaneColumn>([["section", { key: "section", header: "Section" }]]);
+    for (const section of result.sections as Array<{ title: string; rows?: ViewRow[]; entries?: Array<{ label: string; value: unknown }>; columns?: HeadlessPaneColumn[] }>) {
+      for (const column of section.columns ?? []) columns.set(column.key, column);
+      for (const row of section.rows ?? []) rows.push({ section: section.title, ...row });
+      for (const entry of section.entries ?? []) rows.push({ section: section.title, label: entry.label, value: entry.value });
+    }
+    return { rows, columns: [...columns.values()] };
+  }
+  if (Array.isArray(result.series)) {
+    // A series flattens into rows of date plus one column per series.
+    const byDate = new Map<string, ViewRow>();
+    const columns: HeadlessPaneColumn[] = [{ key: "date", header: "Date" }];
+    for (const series of result.series as Array<{ id: string; label: string; points: Array<Record<string, unknown>> }>) {
+      columns.push({ key: series.id, header: series.label, align: "right" });
+      for (const point of series.points) {
+        const date = String(point.date);
+        const row = byDate.get(date) ?? { date };
+        row[series.id] = point.value ?? point.close ?? null;
+        byDate.set(date, row);
+      }
+    }
+    return { rows: [...byDate.values()], columns };
+  }
+  return { rows: [], columns: [] };
+}
+
+/**
+ * Runs the spec's source through the same headless loader ASKG and the CLI
+ * use, so a view shows exactly what those tools would read.
+ */
+export async function loadViewSource(
+  spec: ViewSpec,
+  config: AppConfig,
+  signal: AbortSignal,
+  depth = 0,
+): Promise<LoadedView> {
+  if (spec.source.kind === "ref") {
+    if (depth > 2) throw new Error("This view references itself.");
+    if (!refResolver) throw new Error("Team views are not available right now.");
+    const resolved = await refResolver(spec.source);
+    if (!resolved) throw new Error("The referenced team view no longer exists.");
+    return loadViewSource(resolved, config, signal, depth + 1);
+  }
+  const registry = getSharedRegistry();
+  if (!registry) throw new Error("The plugin registry is not available.");
+  const options: Record<string, string | true> = {};
+  for (const [key, value] of Object.entries(spec.source.options ?? {})) {
+    options[key] = value === true ? true : String(value);
+  }
+  const context = marketContextFromRegistry(registry, config);
+  const resolved = await resolvePaneFunction(registry, context, {
+    target: spec.source.pane,
+    arg: spec.source.argument ?? "",
+    options,
+    outputPath: null,
+    width: 1280,
+    height: 720,
+    theme: null,
+    scale: 1,
+    watermark: null,
+    requireBotSafe: false,
+  }, { strictHeadlessOptions: true });
+  if (!resolved.headless) throw new Error(`${resolved.label} has no data function to build a view from.`);
+  const loaded = await loadResolvedHeadlessPaneModel(resolved, context, spec.source.argument ?? "", signal);
+  const serialized = serializeHeadlessPaneResult(loaded.definition, loaded.result);
+  const { rows, columns } = rowsFromResult(serialized);
+  return {
+    rows,
+    columns,
+    errors: (loaded.result.errors ?? []).filter(Boolean),
+    sourceLabel: resolved.label,
+  };
+}

package/src/plugins/builtin/custom-view/pane.tsx

@@ -0,0 +1,308 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { apiClient, TeamRevisionConflictError } from "../../../api-client";
+import { DataTableView } from "../../../components/data-table/view";
+import { ChoiceDialog } from "../../../components/ui/choice-dialog";
+import { useDialog, type PromptContext } from "../../../ui/dialog";
+import { getSharedRegistry } from "../../registry";
+import { runPaneTemplateDialogWizard } from "../../../app/pane-template-dialog-wizard";
+import { teamPrefix } from "../cloud/team/model";
+import { teamStore } from "../cloud/team/store";
+import { teamViewsStore } from "../cloud/team/views";
+import { setPaneSettings } from "../../../pane-settings";
+import { customViewInstanceSettings } from "./index";
+import type { DataTableColumn } from "../../../components/ui/data-table/types";
+import { EmptyState, PaneStatusBody, usePaneFooter } from "../../../components";
+import { useAsyncResource } from "../../../react/async-resource";
+import { useShortcut } from "../../../react/input";
+import { usePaneInstance, usePaneAppConfig } from "../../../state/app/context";
+import { colors } from "../../../theme/colors";
+import type { PaneProps } from "../../../types/plugin";
+import { Box, Text } from "../../../ui";
+import { usePluginAppActions, usePluginPaneActions } from "../../runtime";
+import { useAutoRefresh } from "../shared/auto-refresh";
+import { loadViewSource, type LoadedView } from "./loader";
+import {
+  applyViewProjection,
+  formatViewValue,
+  parseViewSpecOr,
+  type ViewColumn,
+  type ViewRow,
+  type ViewSort,
+  type ViewSpec,
+} from "./view-spec";
+
+export const CUSTOM_VIEW_PANE_ID = "custom-view";
+export const CUSTOM_VIEW_SPEC_SETTING = "spec";
+
+type Column = DataTableColumn & { key: string; transform?: ViewColumn["transform"] };
+
+const DEFAULT_COLUMN_WIDTH = 14;
+
+function columnsFor(spec: ViewSpec, loaded: LoadedView | null): Column[] {
+  const known = new Map((loaded?.columns ?? []).map((column) => [column.key, column]));
+  const picked: ViewColumn[] = spec.projection.columns.length > 0
+    ? spec.projection.columns
+    : (loaded?.columns ?? []).map((column) => ({ key: column.key }));
+  return picked.map((column, index) => {
+    const source = known.get(column.key);
+    const align = column.align ?? source?.align ?? "left";
+    return {
+      id: column.key,
+      key: column.key,
+      label: column.label ?? source?.header ?? column.key,
+      align: align === "right" ? "right" : "left",
+      width: column.width ?? (index === 0 ? 18 : DEFAULT_COLUMN_WIDTH),
+      ...(index === 0 ? { flexGrow: 1 } : {}),
+      transform: column.transform,
+    };
+  });
+}
+
+export function CustomViewPane({ focused, width, height }: PaneProps) {
+  const instance = usePaneInstance();
+  const config = usePaneAppConfig();
+  const { selectTicker } = usePluginPaneActions();
+  const { notify } = usePluginAppActions();
+  const dialog = useDialog();
+  const rawSpec = instance?.settings?.[CUSTOM_VIEW_SPEC_SETTING];
+  const parsed = useMemo(() => (rawSpec ? parseViewSpecOr(rawSpec) : null), [rawSpec]);
+  const spec = parsed && "spec" in parsed ? parsed.spec : null;
+  const specError = parsed && "error" in parsed ? parsed.error : null;
+  const [sort, setSort] = useState<ViewSort | null | undefined>(undefined);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  const loader = useCallback(async () => {
+    if (!spec) throw new Error(specError ?? "This view has no spec yet.");
+    const controller = new AbortController();
+    return loadViewSource(spec, config, controller.signal);
+  }, [config, spec, specError]);
+  const { data, loading, error, reload, updatedAt } = useAsyncResource(spec ? loader : null);
+  useAutoRefresh(updatedAt, reload);
+
+  useEffect(() => {
+    setSort(undefined);
+  }, [spec]);
+
+  const columns = useMemo(() => (spec ? columnsFor(spec, data) : []), [data, spec]);
+  const rows = useMemo(
+    () => (spec && data ? applyViewProjection(data.rows, spec.projection, sort) : []),
+    [data, sort, spec],
+  );
+  const baseByColumn = useMemo(() => {
+    const bases = new Map<string, number>();
+    for (const column of columns) {
+      if (column.transform !== "index100") continue;
+      const first = rows.find((row) => typeof row[column.key] === "number")?.[column.key];
+      if (typeof first === "number") bases.set(column.key, first);
+    }
+    return bases;
+  }, [columns, rows]);
+  const symbolKey = spec?.presentation.symbolKey ?? (columns.some((column) => column.key === "symbol") ? "symbol" : null);
+  const activeSort = sort === undefined ? spec?.projection.sort ?? null : sort;
+  // Memoized so the table's row memo holds while the selection moves.
+  const rowKey = useCallback((row: ViewRow, index: number) => (
+    `${symbolKey && typeof row[symbolKey] === "string" ? row[symbolKey] : ""}:${index}`
+  ), [symbolKey]);
+  const renderRowCell = useCallback((row: ViewRow, column: Column) => ({
+    text: formatViewValue(row[column.key], column.transform, baseByColumn.get(column.key)),
+    color: column.key === symbolKey ? colors.textBright : undefined,
+  }), [baseByColumn, symbolKey]);
+
+  /**
+   * Publishes this view to a team. An inline view becomes a new team view
+   * and this pane starts following it; a view that already follows a team
+   * view pushes a revision with If-Match and asks on conflict.
+   */
+  const publishToTeam = useCallback(async () => {
+    if (!spec || !instance) return;
+    const teams = teamStore.getSnapshot().teams;
+    if (teams.length === 0) {
+      notify({ body: "Join or create a team first with TEAM.", type: "info" });
+      return;
+    }
+    try {
+      if (spec.source.kind === "ref") {
+        const current = teamViewsStore.get(spec.source.viewId) ?? (await apiClient.getTeamView(spec.source.viewId));
+        if (!current) throw new Error("This team view no longer exists.");
+        const currentParsed = parseViewSpecOr(current.spec);
+        const values = await runPaneTemplateDialogWizard(dialog, [{
+          key: "spec",
+          label: `Publish a revision of ${current.name}`,
+          type: "textarea",
+          defaultValue: JSON.stringify("spec" in currentParsed ? currentParsed.spec : current.spec, null, 2),
+          body: [`Edit the spec, or ask Gloom to. Enter publishes r${current.revision + 1}.`],
+        }]);
+        const edited = values?.spec ? parseViewSpecOr(values.spec) : null;
+        if (!edited) return;
+        if ("error" in edited) throw new Error(edited.error);
+        try {
+          const published = await apiClient.publishTeamViewRevision(current.id, {
+            spec: edited.spec as unknown as Record<string, unknown>,
+            expectedRevision: current.revision,
+          });
+          teamViewsStore.upsert(published);
+          notify({ body: `Published ${published.name} r${published.revision}.`, type: "success" });
+          void reload();
+        } catch (error) {
+          if (!(error instanceof TeamRevisionConflictError)) throw error;
+          const choice = await dialog.prompt<string>({
+            closeOnClickOutside: false,
+            content: (context: PromptContext<string>) => (
+              <ChoiceDialog
+                {...context}
+                title={`A teammate published r${error.currentRevision} first`}
+                choices={[
+                  { id: "overwrite", label: "Overwrite with mine", description: `Publishes yours as r${error.currentRevision + 1}.` },
+                  { id: "reload", label: "Take theirs", description: "This pane follows their revision." },
+                ]}
+                selectedChoiceId="reload"
+              />
+            ),
+          }).catch(() => undefined);
+          if (choice === "overwrite") {
+            const published = await apiClient.publishTeamViewRevision(current.id, {
+              spec: edited.spec as unknown as Record<string, unknown>,
+              expectedRevision: error.currentRevision,
+            });
+            teamViewsStore.upsert(published);
+            notify({ body: `Published ${published.name} r${published.revision}.`, type: "success" });
+          }
+          void reload();
+        }
+        return;
+      }
+
+      const defaultTeam = teamStore.getDefaultTeamId();
+      const teamId = teams.length === 1
+        ? teams[0]!.id
+        : await dialog.prompt<string>({
+          closeOnClickOutside: true,
+          content: (context: PromptContext<string>) => (
+            <ChoiceDialog
+              {...context}
+              title="Publish this view to"
+              choices={teams.map((team) => ({ id: team.id, label: `${teamPrefix(team)} ${team.name}` }))}
+              selectedChoiceId={defaultTeam ?? undefined}
+            />
+          ),
+        }).catch(() => undefined);
+      if (!teamId) return;
+      const values = await runPaneTemplateDialogWizard(dialog, [{
+        key: "name",
+        label: "View name",
+        type: "text",
+        defaultValue: instance.title ?? spec.presentation.title ?? "",
+        placeholder: "Top movers",
+      }]);
+      if (!values?.name) return;
+      const created = await apiClient.createTeamView(teamId, {
+        name: values.name,
+        spec: { ...spec, presentation: { ...spec.presentation, title: values.name } } as unknown as Record<string, unknown>,
+      });
+      teamViewsStore.upsert(created);
+      // This pane now follows the team view, so a teammate's revision reaches it.
+      const registry = getSharedRegistry();
+      if (registry) {
+        const following: ViewSpec = {
+          version: 1,
+          source: { kind: "ref", viewId: created.id, teamId },
+          projection: { columns: [], filters: [] },
+          presentation: { title: values.name },
+        };
+        registry.updateLayoutFn(setPaneSettings(registry.getLayoutFn(), instance.instanceId, {
+          ...instance.settings,
+          ...customViewInstanceSettings(following),
+        }));
+      }
+      const team = teams.find((entry) => entry.id === teamId);
+      notify({ body: `Published "${values.name}" to ${team?.name ?? "the team"}. Members find it as ${team ? teamPrefix(team) : ""} ${values.name}.`, type: "success" });
+    } catch (error) {
+      notify({ body: error instanceof Error ? error.message : "Could not publish the view.", type: "error" });
+    }
+  }, [dialog, instance, notify, reload, spec]);
+
+  useShortcut((event) => {
+    if (!focused) return;
+    if (event.name === "r" && !event.ctrl && !event.meta) {
+      event.preventDefault?.();
+      void reload();
+    } else if (event.name === "t" && !event.ctrl && !event.meta && spec) {
+      event.preventDefault?.();
+      void publishToTeam();
+    }
+  });
+
+  usePaneFooter(CUSTOM_VIEW_PANE_ID, () => ({
+    info: [
+      { id: "source", parts: [{ text: data?.sourceLabel ?? (spec?.source.kind === "inline" ? spec.source.pane : "team view"), tone: "muted" as const }] },
+      ...(data?.errors.length ? [{ id: "errors", parts: [{ text: data.errors[0]!, tone: "warning" as const }] }] : []),
+      { id: "count", parts: [{ text: `${rows.length} rows`, tone: "muted" as const }] },
+    ],
+    hints: [
+      { id: "refresh", key: "r", label: "efresh", onPress: () => { void reload(); } },
+      ...(spec ? [{ id: "team", key: "t", label: spec.source.kind === "ref" ? "eam revision" : "eam publish", onPress: () => { void publishToTeam(); } }] : []),
+    ],
+  }), [data?.errors, data?.sourceLabel, publishToTeam, reload, rows.length, spec]);
+
+  if (!spec) {
+    return (
+      <Box width={width} height={height} padding={1} flexDirection="column" gap={1}>
+        <EmptyState
+          status={specError ? "error" : "empty"}
+          title={specError ? "This view's spec is invalid." : "This view is empty."}
+          message={specError ?? "Ask Gloom to build one: \"make a view of the top S&P movers sorted by change\"."}
+          hint="A view is a data function plus columns, a filter, and a sort. Publish it to a team from the gallery."
+        />
+      </Box>
+    );
+  }
+
+  if (loading && !data) {
+    return <PaneStatusBody loading align="center" width={width} height={height} loadingLabel="Loading view..." />;
+  }
+  if (error && !data) {
+    return (
+      <Box width={width} height={height} padding={1} flexDirection="column" gap={1}>
+        <EmptyState status="error" title="This view could not load." message={error} hint="r to retry" />
+      </Box>
+    );
+  }
+  if (rows.length === 0) {
+    return (
+      <Box width={width} height={height} padding={1} flexDirection="column" gap={1}>
+        <EmptyState title="No rows match this view." message={data?.errors[0]} />
+        {spec.presentation.title ? <Text fg={colors.textDim}>{spec.presentation.title}</Text> : null}
+      </Box>
+    );
+  }
+
+  return (
+    <DataTableView<ViewRow, Column>
+      focused={focused}
+      rootWidth={width}
+      rootHeight={height}
+      selection={{
+        kind: "index",
+        selectedIndex,
+        onChange: (index) => setSelectedIndex(index),
+      }}
+      columns={columns}
+      items={rows}
+      sortColumnId={activeSort?.by ?? null}
+      sortDirection={activeSort?.direction ?? "desc"}
+      onHeaderClick={(id) => setSort((current) => {
+        const active = current === undefined ? spec.projection.sort ?? null : current;
+        return active?.by === id
+          ? { by: id, direction: active.direction === "desc" ? "asc" : "desc" }
+          : { by: id, direction: "desc" };
+      })}
+      getItemKey={rowKey}
+      renderCell={renderRowCell}
+      onActivate={(row) => {
+        const symbol = symbolKey ? row[symbolKey] : null;
+        if (typeof symbol === "string" && symbol) selectTicker(symbol);
+      }}
+      emptyStateTitle="No rows."
+    />
+  );
+}

package/src/plugins/builtin/custom-view/view-spec.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import {
+  applyViewProjection,
+  formatViewValue,
+  normalizeViewSpec,
+  parseViewSpec,
+  parseViewSpecOr,
+  serializeViewSpec,
+  validateViewSpec,
+} from "./view-spec";
+
+const good = {
+  version: 1,
+  source: { kind: "inline", pane: "SCR", argument: "sp500", options: { limit: 50, kind: "gainers" } },
+  projection: {
+    columns: ["symbol", { key: "change", label: "Chg", transform: "percent", align: "right" }],
+    filters: [{ key: "change", op: "gt", value: 0.02 }],
+    sort: { by: "change", direction: "desc" },
+    limit: 20,
+  },
+  presentation: { title: "Big movers", symbolKey: "symbol" },
+};
+
+describe("view spec parsing", () => {
+  test("normalizes shorthand columns, defaults, and drops junk", () => {
+    const spec = normalizeViewSpec({
+      ...good,
+      projection: { ...good.projection, columns: [...good.projection.columns, 7, { nope: true }], filter: undefined },
+      presentation: { title: "  Big movers ", density: "loud", extra: 1 },
+    });
+    expect(spec.projection.columns).toEqual([
+      { key: "symbol" },
+      { key: "change", label: "Chg", transform: "percent", align: "right" },
+    ]);
+    expect(spec.projection.sort).toEqual({ by: "change", direction: "desc" });
+    expect(spec.presentation).toEqual({ title: "Big movers" });
+    expect(spec.source).toEqual({ kind: "inline", pane: "SCR", argument: "sp500", options: { limit: 50, kind: "gainers" } });
+  });
+
+  test("accepts JSON strings and objects, rejects invalid specs with reasons", () => {
+    expect(parseViewSpec(JSON.stringify(good))).not.toBeNull();
+    expect(parseViewSpec(good)).not.toBeNull();
+    expect(parseViewSpec("{ not json")).toBeNull();
+    expect(parseViewSpec({ ...good, version: 2 })).toBeNull();
+    expect(parseViewSpec({ ...good, source: { kind: "inline", pane: "" } })).toBeNull();
+    const bad = parseViewSpecOr({
+      ...good,
+      projection: { filters: [{ key: "change", op: "between", value: 1 }, { key: "x", op: "in", value: 3 }], limit: 0 },
+    });
+    expect("error" in bad ? bad.error : "").toContain("projection.filters.0.op");
+    expect("error" in bad ? bad.error : "").toContain("projection.limit");
+    expect(() => serializeViewSpec(normalizeViewSpec({ ...good, version: 9 }))).toThrow();
+  });
+
+  test("ref sources need an id and carry the team", () => {
+    const spec = normalizeViewSpec({ source: { kind: "ref", viewId: "v1", teamId: "org-1" } });
+    expect(spec.source).toEqual({ kind: "ref", viewId: "v1", teamId: "org-1" });
+    expect(validateViewSpec(normalizeViewSpec({ source: { kind: "ref" } })).valid).toBe(false);
+    const warned = validateViewSpec(normalizeViewSpec({ ...good, projection: { columns: ["a", "a"] } }));
+    expect(warned.valid).toBe(true);
+    expect(warned.warnings.map((entry) => entry.code)).toEqual(["duplicate-key"]);
+  });
+});
+
+describe("applyViewProjection", () => {
+  const rows = [
+    { symbol: "AAPL", change: 0.03, sector: "Tech" },
+    { symbol: "XOM", change: -0.01, sector: "Energy" },
+    { symbol: "NVDA", change: 0.08, sector: "Tech" },
+    { symbol: "MSFT", change: 0.025, sector: null },
+  ];
+
+  test("filters, sorts, and limits", () => {
+    const spec = normalizeViewSpec(good);
+    expect(applyViewProjection(rows, spec.projection).map((row) => row.symbol)).toEqual(["NVDA", "AAPL", "MSFT"]);
+    expect(applyViewProjection(rows, { ...spec.projection, limit: 1 }).map((row) => row.symbol)).toEqual(["NVDA"]);
+    expect(applyViewProjection(rows, spec.projection, { by: "change", direction: "asc" }).map((row) => row.symbol)).toEqual(["MSFT", "AAPL", "NVDA"]);
+    expect(applyViewProjection(rows, spec.projection, null).map((row) => row.symbol)).toEqual(["AAPL", "NVDA", "MSFT"]);
+  });
+
+  test("supports every operator", () => {
+    const run = (op: string, value?: unknown) => applyViewProjection(rows, {
+      columns: [],
+      filters: [{ key: op === "exists" ? "sector" : op === "contains" ? "symbol" : "change", op: op as never, ...(value === undefined ? {} : { value: value as never }) }],
+    }).map((row) => row.symbol);
+    expect(run("exists")).toEqual(["AAPL", "XOM", "NVDA"]);
+    expect(run("contains", "vd")).toEqual(["NVDA"]);
+    expect(run("in", [0.03, 0.08])).toEqual(["AAPL", "NVDA"]);
+    expect(run("eq", 0.08)).toEqual(["NVDA"]);
+    expect(run("neq", 0.08)).toEqual(["AAPL", "XOM", "MSFT"]);
+    expect(run("lte", 0.025)).toEqual(["XOM", "MSFT"]);
+    expect(run("gte", 0.03)).toEqual(["AAPL", "NVDA"]);
+    expect(run("lt", 0)).toEqual(["XOM"]);
+  });
+});
+
+describe("formatViewValue", () => {
+  test("applies transforms", () => {
+    expect(formatViewValue(0.1234, "percent")).toBe("12.34%");
+    expect(formatViewValue(1_234_567, "compact")).toBe("1.2M");
+    expect(formatViewValue(-3, "abs")).toBe("3");
+    expect(formatViewValue(110, "index100", 100)).toBe("110.0");
+    expect(formatViewValue(3.14159, undefined)).toBe("3.14");
+    expect(formatViewValue("text", "percent")).toBe("text");
+    expect(formatViewValue(null, "compact")).toBe("");
+  });
+});