@gloom-sh/terminal 0.19.2 → 0.19.3

package/src/plugins/builtin/world-venue-map/layered-pane.tsx

@@ -26,6 +26,8 @@ import {
   type DataTableCell,
   type PageRequest,
   type PaneHint,
+  type QueryBarFilter,
+  TickerBadgeList,
 } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import {
@@ -36,13 +38,17 @@ import {
   usePluginPaneState,
 } from "../../../public/react";
 import { relativeLuminance } from "../../../theme/color-utils";
+import { displayWidth } from "../../../utils/format";
+import { truncateWithEllipsis } from "../../../utils/text-wrap";
 import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, Text, TextAttributes, useUiCapabilities, type ScrollBoxRenderable } from "../../../ui";
 import { formatGeoSeriesExpression } from "../chart-composer/series-expression";
 import { CLOUD_PLAN_KEY, useCloudUpgradeAction } from "../shared/cloud-upgrade";
 import { useOpenDescription } from "../shared/open-description";
-import { ENTITY_PAGE_SIZE, loadEntityDetail, loadEntityPage, loadWorldVenues } from "./client";
+import { ENTITY_PAGE_SIZE, loadEntityDetail, loadEntityPage, loadWorldVenues, scopedGeoRequest } from "./client";
+import { isLocalGeoLayer } from "./local-layers";
+import { useLinkedGeoScope } from "./scope";
 import { EntityDetail } from "./entity-detail";
 import { useWorldMapEvidence } from "./evidence";
 import { entityCellText, entityColumns, TICKER_COLUMN_ID, type EntityColumn } from "./entity-table";
@@ -52,6 +58,7 @@ import { WORLD_VENUE_MAP_PANE_ID } from "./ids";
 import {
   entityOpenZoom,
   entityTableBbox,
+  framePlaces,
   featureAnchor,
   formatGeoValue,
   formatTickerLinks,
@@ -162,7 +169,7 @@ const SelectedEntityHeader = memo(function SelectedEntityHeader({
   return (
     <Box flexDirection="column" height={2} width={width} paddingX={1}>
       <Box flexDirection="row" justifyContent="space-between" width="100%">
-        <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>{row.label}</Text>
+        <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>{truncateWithEllipsis(row.label, Math.max(1, width - 3 - displayWidth(layer.name)))}</Text>
         <Text fg={color}>{layer.name}</Text>
       </Box>
       <Text fg={colors.textMuted}>{meta}</Text>
@@ -193,7 +200,11 @@ export function LayeredMapView({ focused, width, height, layers, tokens, plain =
     setView((current) => sameGeoView(current, next) ? current : next);
   }, []);
   const canAccess = useCallback((layer: GeoLayerInfo) => layer.access !== "pro" || hasProAccess, [hasProAccess]);
-  const states = useGeoLayerFeed(layers, view, visible, { canAccess });
+  // A linked map narrows the app's own layers to what its source pane selects.
+  const linkedScope = useLinkedGeoScope(layers.some((layer) => isLocalGeoLayer(layer.id)));
+  const scope = linkedScope.scope;
+  const request = useMemo(() => scopedGeoRequest(scope?.key ?? null), [scope?.key]);
+  const states = useGeoLayerFeed(layers, view, visible, { canAccess, request });
 
   // A layer coloured by class (ships) takes the first colour, so its own never meets the class colours.
   const colorOrder = useMemo(
@@ -244,7 +255,7 @@ export function LayeredMapView({ focused, width, height, layers, tokens, plain =
       ...(sort.key ? { sort: sort.key, dir: sort.dir } : {}),
       ...(tableBbox ? { bbox: tableBbox } : {}),
       offset,
-    }, signal);
+    }, signal, request);
     const rows = page.rows ?? [];
     const total = typeof page.total === "number" ? page.total : null;
     return {
@@ -252,18 +263,28 @@ export function LayeredMapView({ focused, width, height, layers, tokens, plain =
       rows,
       hasMore: rows.length >= ENTITY_PAGE_SIZE && (total === null || offset + rows.length < total),
       nextOffset: offset + rows.length,
+      scopeKey: scope?.key ?? null,
     };
-  }, [query, sort.dir, sort.key, tableBboxKey, tableLayer.id]);
+  }, [query, request, scope?.key, sort.dir, sort.key, tableBboxKey, tableLayer.id]);
   const pages = usePagedRows(tableReadable ? loadPage : null, { getId: (row) => row.id });
   const rows = pages.rows;
+  // A linked map frames the places of each company or theme it moves to, once.
+  const framedScopeRef = useRef<string | null>(null);
+  const firstPage = pages.pages[0];
+  useEffect(() => {
+    if (!firstPage?.scopeKey || !isLocalGeoLayer(tableLayer.id) || framedScopeRef.current === firstPage.scopeKey) return;
+    framedScopeRef.current = firstPage.scopeKey;
+    const frame = framePlaces(firstPage.rows);
+    if (frame) setFocus({ key: `scope:${firstPage.scopeKey}`, ...frame, exact: true });
+  }, [firstPage, tableLayer.id]);
   useWorldMapEvidence(tokens, states, rows.length, pages.loading);
   const refresh = useCallback(() => pages.reload(), [pages.reload]);
   usePaneRefreshKey(refresh, { focused: focused && !searchFocused });
 
   const detailOpen = !!open && open.layer === tableLayer.id;
   const detailLoader = useMemo(
-    () => (detailOpen && open ? () => loadEntityDetail(open.layer, open.id) : null),
-    [detailOpen, open?.id, open?.layer],
+    () => (detailOpen && open ? () => loadEntityDetail(open.layer, open.id, undefined, request) : null),
+    [detailOpen, open?.id, open?.layer, request],
   );
   const detail = useAsyncResource(detailLoader);
   const openRow = detailOpen
@@ -412,9 +433,29 @@ export function LayeredMapView({ focused, width, height, layers, tokens, plain =
 
   const onScroll = useTableLoadMore(scrollRef, pages.hasMore && !detailOpen, pages.loadMore);
   // A layer that cannot serve has nothing to search and, alone, nothing to switch to: no bar at all.
+  // What a linked map shows, before the search: a switch between the company and its theme when the
+  // source has both, else the one it has.
+  const scoped = !!scope && isLocalGeoLayer(tableLayer.id);
+  const { company: scopeCompany, theme: scopeTheme } = linkedScope;
+  const scopeFilter: QueryBarFilter | null = scoped && scopeCompany && scopeTheme ? {
+    id: "scope",
+    label: "Show",
+    inline: true,
+    value: linkedScope.mode,
+    options: [
+      { value: "company", label: scopeCompany.label },
+      { value: "theme", label: "Theme", description: scopeTheme.label },
+    ],
+    onChange: linkedScope.setMode,
+  } : null;
+  const scopeLeading = !scoped || scopeFilter ? undefined
+    : scopeCompany ? <TickerBadgeList symbols={[scopeCompany.label]} width={displayWidth(scopeCompany.label) + 2} listed />
+      : <Text fg={colors.textDim}>{truncateWithEllipsis(scope.label, Math.max(8, Math.floor(listWidth / 3)))}</Text>;
   const queryBar = !tableReadable && layers.length < 2 ? undefined : (
     <QueryBar
       width={listWidth}
+      leading={scopeLeading}
+      filters={scopeFilter ? [scopeFilter] : undefined}
       search={tableReadable ? {
         value: query,
         onChange: setQuery,

package/src/plugins/builtin/world-venue-map/layers.ts

@@ -142,6 +142,7 @@ export const MAP_PRESET_OPTIONS = [
   { value: "ports", label: "Ports" },
   { value: "energy", label: "Pipelines, fields and terminals" },
   { value: "air", label: "Airports and flights" },
+  { value: "facilities", label: "AI buildout facilities" },
 ] as const;
 
 function shortDate(iso: string): string | null {
@@ -329,6 +330,22 @@ export function entityOpenZoom(layer: Pick<GeoLayerInfo, "geometry" | "minZoom">
   return layer.minZoom === undefined ? base : Math.max(base, 2 ** layer.minZoom);
 }
 
+/** Below this span a frame is a region, not a street: one facility shows its surroundings. */
+const FRAME_MIN_SPAN_DEGREES = 6;
+const FRAME_MAX_ZOOM = 8;
+
+/** The centre and zoom that frame a set of places (a linked company's facilities); null without one. */
+export function framePlaces(places: readonly { lon: number; lat: number }[]): { longitude: number; latitude: number; zoom: number } | null {
+  const located = places.filter((place) => Number.isFinite(place.lon) && Number.isFinite(place.lat));
+  if (!located.length) return null;
+  const lons = located.map((place) => place.lon);
+  const lats = located.map((place) => place.lat);
+  const west = Math.min(...lons), east = Math.max(...lons), south = Math.min(...lats), north = Math.max(...lats);
+  // The map is about twice as wide as tall, so latitude counts double; a margin keeps edge markers inside.
+  const span = Math.max(east - west, (north - south) * 2, FRAME_MIN_SPAN_DEGREES) * 1.5;
+  return { longitude: (west + east) / 2, latitude: (south + north) / 2, zoom: Math.min(FRAME_MAX_ZOOM, Math.max(1, 360 / span)) };
+}
+
 /**
  * The area a layer's table reads. A layer drawn only from a zoom (live
  * flights) lists what the map shows once it is that close; further out, and

package/src/plugins/builtin/world-venue-map/local-layers.ts

@@ -0,0 +1,141 @@
+/**
+ * Layers the app serves itself, beside the server's catalog. A plugin whose
+ * rows have a place (TheBuildout's facilities) registers one, and the map,
+ * its table and its detail read it through the same wire contract as a server
+ * layer: the catalog lists it, and its feature, entity and detail requests are
+ * answered in the app without reaching Gloom Cloud. A scope (the company or
+ * theme the pane follows) narrows what a local layer answers; server layers
+ * never see it.
+ */
+import {
+  resetGeoCatalogCache,
+  type GeoBbox,
+  type GeoEntitiesPayload,
+  type GeoEntityPayload,
+  type GeoFeaturesPayload,
+  type GeoLayerInfo,
+  type GeoLayersPayload,
+  type GeoRequest,
+} from "../../../api-client/geo";
+import { logFailure } from "../../../utils/log-failure";
+
+/** What a linked map narrows a local layer to: `company:CRWV`, `theme:<slug>`. */
+export interface GeoScope {
+  key: string;
+  /** The words the pane shows for it: a ticker or a theme's name. */
+  label: string;
+}
+
+export interface LocalFeatureQuery {
+  bbox: GeoBbox | null;
+  zoom: number;
+  limit: number;
+  scope: string | null;
+}
+
+export interface LocalEntityQuery {
+  q: string;
+  sort: string | null;
+  dir: "asc" | "desc";
+  limit: number;
+  offset: number;
+  bbox: GeoBbox | null;
+  scope: string | null;
+}
+
+export interface LocalGeoLayer {
+  info: GeoLayerInfo;
+  features: (query: LocalFeatureQuery, signal?: AbortSignal) => Promise<GeoFeaturesPayload>;
+  entities: (query: LocalEntityQuery, signal?: AbortSignal) => Promise<GeoEntitiesPayload>;
+  entity: (id: string, scope: string | null, signal?: AbortSignal) => Promise<GeoEntityPayload>;
+}
+
+const localLayers = new Map<string, LocalGeoLayer>();
+
+/** Adds a layer to every map's catalog until the returned function removes it. */
+export function registerLocalGeoLayer(layer: LocalGeoLayer): () => void {
+  localLayers.set(layer.info.id, layer);
+  // A catalog read before the layer existed would hide it for minutes.
+  resetGeoCatalogCache();
+  return () => {
+    if (localLayers.get(layer.info.id) !== layer) return;
+    localLayers.delete(layer.info.id);
+    resetGeoCatalogCache();
+  };
+}
+
+export function isLocalGeoLayer(layerId: string): boolean {
+  return localLayers.has(layerId);
+}
+
+function bboxParam(value: string | null): GeoBbox | null {
+  if (!value) return null;
+  const parts = value.split(",").map(Number);
+  return parts.length === 4 && parts.every(Number.isFinite) ? parts as GeoBbox : null;
+}
+
+function numberParam(value: string | null, fallback: number): number {
+  const parsed = value === null ? Number.NaN : Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+/** The server's catalog with the local layers after it; a server without one still lists them. */
+async function mergedCatalog(request: GeoRequest, init?: RequestInit): Promise<GeoLayersPayload> {
+  const local = [...localLayers.values()].map((layer) => layer.info);
+  const server = await request<GeoLayersPayload>("layers", init).catch((error: unknown) => {
+    if (!local.length) throw error;
+    logFailure("cloud-geo", "Geo catalog request failed")(error);
+    return null;
+  });
+  const serverLayers = Array.isArray(server?.layers) ? server.layers : [];
+  const ids = new Set(serverLayers.map((layer) => layer?.id));
+  return { layers: [...serverLayers, ...local.filter((layer) => !ids.has(layer.id))], asOf: server?.asOf ?? null };
+}
+
+/** A path segment as written when it is not valid percent-encoding (a stray `%` in an entity id). */
+function decodeSegment(segment: string): string {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    // Intentional ignore: a segment that does not decode is matched as it was written.
+    return segment;
+  }
+}
+
+/**
+ * A request that answers the local layers itself and sends everything else on.
+ * `scope` narrows the local layers' answers; a new scope is a new request
+ * function, so the map's feed and table ask again.
+ */
+export function withLocalGeoLayers(request: GeoRequest, scope: string | null = null): GeoRequest {
+  return (<T>(path: string, init?: RequestInit): Promise<T> => {
+    const [route = "", search = ""] = path.split("?");
+    const params = new URLSearchParams(search);
+    const signal = init?.signal ?? undefined;
+    if (route === "layers") return (localLayers.size ? mergedCatalog(request, init) : request(path, init)) as Promise<T>;
+    const parts = route.split("/").map(decodeSegment);
+    const layer = parts.length >= 3 ? localLayers.get(parts[1]!) ?? null : null;
+    if (parts[0] === "layers" && layer && parts[2] === "features") {
+      return layer.features({
+        bbox: bboxParam(params.get("bbox")),
+        zoom: numberParam(params.get("zoom"), 0),
+        limit: numberParam(params.get("limit"), 1500),
+        scope,
+      }, signal) as Promise<T>;
+    }
+    if (parts[0] === "layers" && layer && parts[2] === "entities") {
+      return layer.entities({
+        q: params.get("q") ?? "",
+        sort: params.get("sort"),
+        dir: params.get("dir") === "asc" ? "asc" : "desc",
+        limit: numberParam(params.get("limit"), 100),
+        offset: numberParam(params.get("offset"), 0),
+        bbox: bboxParam(params.get("bbox")),
+        scope,
+      }, signal) as Promise<T>;
+    }
+    const entityLayer = parts[0] === "entities" ? localLayers.get(parts[1] ?? "") : undefined;
+    if (entityLayer && parts[2]) return entityLayer.entity(parts.slice(2).join("/"), scope, signal) as Promise<T>;
+    return request<T>(path, init);
+  }) as GeoRequest;
+}

package/src/plugins/builtin/world-venue-map/map-symbols.ts

@@ -18,6 +18,9 @@ export type MapSymbolId =
   | "terminal"
   | "field"
   | "chokepoint"
+  | "rack"
+  | "bolt"
+  | "chip"
   | "dot";
 
 export interface MapSymbol {
@@ -85,6 +88,17 @@ export const MAP_SYMBOLS: Record<MapSymbolId, MapSymbol> = {
     landmark: true,
     cell: "◆",
   },
+  // A server rack: the cabinet and its shelves, for a data center.
+  rack: { d: "M-5 -7.2H5V7.2H-5ZM-5 -2.4H5M-5 2.4H5M-2.6 -4.8H-0.6M-2.6 0H-0.6M-2.6 4.8H-0.6", paint: "stroke", size: 13, cell: "▤" },
+  // A lightning bolt, for a power plant or substation.
+  bolt: { d: "M1.8 -8L-5.4 1.4H-0.6L-2 8L5.4 -1.8H0.6Z", paint: "fill", size: 13, cell: "↯" },
+  // A chip and its pins, for a fab or a packaging plant.
+  chip: {
+    d: "M-4.6 -4.6H4.6V4.6H-4.6ZM-2 -4.6V-7.6M2 -4.6V-7.6M-2 4.6V7.6M2 4.6V7.6M-4.6 -2H-7.6M-4.6 2H-7.6M4.6 -2H7.6M4.6 2H7.6",
+    paint: "stroke",
+    size: 13,
+    cell: "▣",
+  },
   dot: { d: "M0 -3.4A3.4 3.4 0 1 1 0 3.4A3.4 3.4 0 1 1 0 -3.4Z", paint: "fill", size: 11, cell: "•" },
 };
 
@@ -162,6 +176,10 @@ const RULES: Record<string, SymbolRule> = {
   },
   terminal: () => fixed("terminal"),
   field: () => fixed("field"),
+  // Facilities (TheBuildout): by what the site is; anything else is a dot.
+  "data-center": () => fixed("rack"),
+  "power-plant": () => fixed("bolt"),
+  fab: () => fixed("chip"),
 };
 
 /** The layer registry: layer ids the app knows, then the kinds their entities carry. */

package/src/plugins/builtin/world-venue-map/map.tsx

@@ -43,6 +43,8 @@ export interface WorldMapFocus {
   longitude: number;
   latitude: number;
   zoom?: number;
+  /** Exactly at `zoom`, out as well as in: a frame around a set of places. */
+  exact?: boolean;
 }
 
 interface WorldVenueMapProps {
@@ -690,8 +692,8 @@ function DesktopWorldVenueMap(props: WorldVenueMapProps) {
     if (!focus || !sized || appliedFocusRef.current === focus.key) return;
     appliedFocusRef.current = focus.key;
     setViewport((current) => {
-      const zoom = Math.max(current.zoom, focus.zoom ?? 1);
-      if (zoom <= 1) return current;
+      const zoom = focus.exact ? Math.max(1, focus.zoom ?? 1) : Math.max(current.zoom, focus.zoom ?? 1);
+      if (zoom <= 1 && !focus.exact) return current;
       return clampWorldMapViewport({ zoom, centerLongitude: focus.longitude, centerLatitude: focus.latitude }, props.width, plotHeight, 1, maxZoom);
     });
   }, [focusKey, sized]);

package/src/plugins/builtin/world-venue-map/scope.ts

@@ -0,0 +1,63 @@
+import { useMemo } from "react";
+import { useAppSelector, usePaneInstance } from "../../../state/app/context";
+import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
+import { usePluginPaneState } from "../../../public/react";
+import type { PaneInstanceConfig } from "../../../types/config";
+import { parseLayerTokens, LAYERS_SETTING_KEY } from "./layers";
+import { isLocalGeoLayer, type GeoScope } from "./local-layers";
+
+/**
+ * Pane state a ticker source may publish beside `cursorSymbol`: the group the
+ * selected company belongs to, which a linked map can widen to. TheBuildout
+ * publishes the theme its table lists.
+ */
+export const GEO_SCOPE_STATE_KEY = "geoScope";
+
+type GeoScopeMode = "company" | "theme";
+
+function publishedScope(value: unknown): GeoScope | null {
+  if (!value || typeof value !== "object") return null;
+  const { key, label } = value as Partial<GeoScope>;
+  return typeof key === "string" && key && typeof label === "string" ? { key, label } : null;
+}
+
+/** A map with one of the app's own layers on can be linked to a list's or a scanner's selection. */
+export function mapFollowsTicker(pane: PaneInstanceConfig): boolean {
+  return parseLayerTokens(pane.settings?.[LAYERS_SETTING_KEY]).some(isLocalGeoLayer);
+}
+
+export interface LinkedGeoScope {
+  /** What the map's own layers show; null shows everything. */
+  scope: GeoScope | null;
+  /** The company the link resolves to. */
+  company: GeoScope | null;
+  /** The group its source publishes for that company. */
+  theme: GeoScope | null;
+  mode: GeoScopeMode;
+  setMode: (mode: GeoScopeMode) => void;
+}
+
+/**
+ * What a linked map narrows its own layers to: the company the link resolves
+ * to, or the theme its source publishes once the pane is switched to it (and
+ * whenever there is no company). An unlinked map has neither and shows
+ * everything.
+ */
+export function useLinkedGeoScope(enabled: boolean): LinkedGeoScope {
+  const instance = usePaneInstance();
+  const linked = enabled && (instance?.binding?.kind === "follow" || instance?.binding?.kind === "fixed");
+  const sourceId = linked && instance?.binding?.kind === "follow" ? instance.binding.sourceInstanceId : null;
+  const published = useAppSelector((state) => (sourceId ? state.paneState[sourceId]?.[GEO_SCOPE_STATE_KEY] ?? null : null));
+  const { symbol } = usePaneTickerIdentity();
+  const [mode, setMode] = usePluginPaneState<GeoScopeMode>("geoScopeMode", "company");
+  const theme = linked ? publishedScope(published) : null;
+  const companySymbol = linked ? symbol : null;
+  const themeKey = theme?.key ?? null;
+  const themeLabel = theme?.label ?? "";
+  return useMemo(() => {
+    const company = companySymbol ? { key: `company:${companySymbol}`, label: companySymbol } : null;
+    const group = themeKey ? { key: themeKey, label: themeLabel } : null;
+    const scope = mode === "theme" ? group ?? company : company ?? group;
+    return { scope, company, theme: group, mode, setMode };
+  }, [companySymbol, mode, setMode, themeKey, themeLabel]);
+}

package/src/plugins/builtin/yield-curve/curves.ts

@@ -44,7 +44,12 @@ export function curveOption(id: CurveId): CurveOption {
   return CURVE_OPTIONS.find((option) => option.id === id) ?? CURVE_OPTIONS[0]!;
 }
 
-/** `GC`, `GC 2026-01-02`, `GC JGB`, `GC TIPS 2024-01-02`: a curve word and a date, either order. */
+/**
+ * `GC`, `GC 2026-01-02`, `GC JGB`, `GC TIPS 2024-01-02`: a curve word and a
+ * date, either order. Words with no digit are no date: one that names no
+ * curve (`GC world`, `GC "South Africa"`) lists the curves and points at the
+ * world tab, which has the other countries' government yields.
+ */
 export function parseCurveArgument(value: unknown, now = new Date()): { curve: CurveId | null; date: string } {
   const words = typeof value === "string" ? value.trim().split(/\s+/).filter(Boolean) : [];
   let curve: CurveId | null = null;
@@ -54,7 +59,16 @@ export function parseCurveArgument(value: unknown, now = new Date()): { curve: C
     if (match && !curve) curve = match.id;
     else rest.push(word);
   }
-  return { curve, date: yieldCurveDate(rest.join(" ") || null, now) };
+  const text = rest.join(" ");
+  if (text && !/\d/.test(text) && text.toLowerCase() !== "latest") throw new Error(unknownCurveMessage(text));
+  return { curve, date: yieldCurveDate(text || null, now) };
+}
+
+/** `Unknown curve "world"`, with the curves there are and where the rest of the world's yields are. */
+export function unknownCurveMessage(word: string): string {
+  const names = CURVE_OPTIONS.map((option) => option.aliases[0]);
+  return `Unknown curve "${word}"; the curves are ${names.slice(0, -1).join(", ")} and ${names.at(-1)}. `
+    + "Other countries' government bond yields are on the world tab: gloom fn GC --tab world.";
 }
 
 /**

package/src/plugins/builtin/yield-curve/headless.ts

@@ -3,8 +3,8 @@ import type {
   HeadlessPaneDefinition,
 } from "../../../types/plugin";
 import {
-  compareDate, curveCutoff, CURVE_OPTIONS, curveIdOf, curveOption, curveSpreadFigures, curveTenorMove, loadComparePoints,
-  parseCompareInput, parseCurveArgument, type CurveData, type CurveId,
+  compareDate, curveCutoff, curveIdOf, curveOption, curveSpreadFigures, curveTenorMove, loadComparePoints,
+  parseCompareInput, parseCurveArgument, unknownCurveMessage, type CurveData, type CurveId,
 } from "./curves";
 import { yieldTenorRows, type YieldLookbackCurves } from "./chart";
 import { curveAsOf, type YieldPoint, yieldCurveErrors } from "./treasury-data";
@@ -194,7 +194,7 @@ export function createYieldCurveHeadless(
       const argument = parseCurveArgument(args.argument);
       const optionCurve = args.options.curve == null || args.options.curve === "" ? null : curveIdOf(args.options.curve);
       if (args.options.curve && !optionCurve) {
-        throw new Error(`Unknown curve ${String(args.options.curve)}; use ${CURVE_OPTIONS.map((option) => option.aliases[0]).join(", ")}.`);
+        throw new Error(unknownCurveMessage(String(args.options.curve)));
       }
       const curve = optionCurve ?? argument.curve ?? "us";
       const requestedDate = args.options.date != null ? yieldCurveDate(args.options.date, new Date(), "--date") : argument.date;

package/src/plugins/bundle.ts

@@ -1,10 +1,16 @@
 import { mkdir } from "fs/promises";
-import { join } from "path";
+import { basename, join } from "path";
 
 import { explainPluginLoadError } from "./compat";
 import { hostPublicModules } from "./host-link";
 import { resolvePluginBrowserEntry, resolvePluginEntry } from "./loader";
+import { siblingImportsBundlerPlugin } from "./peer-imports";
 import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS, importPluginHostModule } from "./host-modules";
+import {
+  PLUGIN_PROCESS_IDENTIFIER,
+  pluginProcessDeclaration,
+  pluginProcessModuleSource,
+} from "./plugin-process";
 
 /**
  * Compiles an external plugin for a renderer that cannot read the filesystem.
@@ -90,6 +96,7 @@ export interface BundlePluginResult {
 function createSharedModuleResolver(
   exportNamesFor: (specifier: string) => Promise<readonly string[]>,
   onShared?: (specifier: string) => void,
+  options: { providesProcess?: boolean } = {},
 ): import("bun").BunPlugin {
   const namespace = "gloom-host";
   const shared = new Set<string>(SHARED_SPECIFIERS);
@@ -118,6 +125,19 @@ function createSharedModuleResolver(
         contents: buildSharedModuleSource(args.path, await exportNamesFor(args.path)),
         loader: "js",
       }));
+
+      if (!options.providesProcess) return;
+      // `import process from "node:process"` reads the same shim as the bare
+      // global. Bun's own browser stand-in has no default export, so without
+      // this such a plugin did not compile for the desktop at all.
+      build.onResolve({ filter: /^(?:node:)?process$/ }, () => ({
+        path: "process",
+        namespace: "gloom-process",
+      }));
+      build.onLoad({ filter: /.*/, namespace: "gloom-process" }, () => ({
+        contents: pluginProcessModuleSource(),
+        loader: "js",
+      }));
     },
   };
 }
@@ -144,6 +164,11 @@ export async function bundleExternalPlugin(
      */
     minify?: boolean;
     define?: Record<string, string>;
+    /**
+     * Named in the errors the browser's `process` stand-in throws. Defaults to
+     * the plugin's folder name.
+     */
+    pluginName?: string;
     /**
      * `bun` compiles the native entry the terminal imports instead. Only the
      * registry check uses it, to cover the native half of a plugin that has
@@ -161,7 +186,16 @@ export async function bundleExternalPlugin(
 
   await mkdir(outDir, { recursive: true });
 
+  // The browser has no `process`, which the terminal gives every plugin. Each
+  // bundle gets its own stand-in (see plugin-process.ts); a bundle compiled
+  // for Bun runs where the real one exists.
+  const providesProcess = (options.target ?? "browser") === "browser";
+  const pluginName = options.pluginName ?? basename(pluginDir);
+
   const shared = new Set<string>();
+  // A sibling plugin it imports is compiled from the sibling's folder, as
+  // the loader imports it, not through the plugin's link (peer-imports.ts).
+  const siblings = siblingImportsBundlerPlugin(pluginDir);
   const result = await Bun.build({
     entrypoints: [entry],
     outdir: outDir,
@@ -174,12 +208,19 @@ export async function bundleExternalPlugin(
     // `errors`. Returning it lets the check below report what actually broke,
     // such as an import this host version does not export.
     throw: false,
-    ...(options.define ? { define: options.define } : {}),
+    // The more specific `process.env.NODE_ENV` a caller defines still wins,
+    // so dead branches keyed on it stay dropped.
+    define: {
+      ...(providesProcess ? { process: PLUGIN_PROCESS_IDENTIFIER } : {}),
+      ...options.define,
+    },
     plugins: [
       createSharedModuleResolver(
         options.exportNamesFor ?? hostExportNames,
         (specifier) => shared.add(specifier),
+        { providesProcess },
       ),
+      ...(siblings ? [siblings] : []),
     ],
   });
 
@@ -188,6 +229,15 @@ export async function bundleExternalPlugin(
   const output = result.outputs.find((entryOutput) => entryOutput.kind === "entry-point");
   if (!output) throw new Error(`Bundling ${pluginDir} produced no entry point`);
 
+  // Only a bundle that reads `process` carries the stand-in, so the rest of
+  // the plugins the web app serves stay as small as they were.
+  if (providesProcess) {
+    const code = await Bun.file(output.path).text();
+    if (code.includes(PLUGIN_PROCESS_IDENTIFIER)) {
+      await Bun.write(output.path, pluginProcessDeclaration(pluginName) + code);
+    }
+  }
+
   return {
     outputPath: output.path,
     shared: [...shared].sort(),

package/src/plugins/catalog-browser.ts

@@ -43,7 +43,7 @@ import { ipoCalendarPlugin } from "./builtin/ipo-calendar";
 import { clinicalTrialsPlugin } from "./builtin/clinical-trials";
 import { commentLettersPlugin } from "./builtin/comment-letters";
 import { openFdaPlugin } from "./builtin/openfda";
-import { browserGloomberbCloudPlugin } from "./builtin/cloud/browser";
+import { gloomberbCloudPlugin } from "./builtin/cloud";
 import { changelogModule } from "./builtin/changelog";
 import { roadmapModule } from "./builtin/roadmap";
 import { chartComposerModule } from "./builtin/chart-composer";
@@ -298,7 +298,7 @@ const browserEarningsPlugin = composeBuiltinPlugin({
  * browser-safe public API are absent rather than registered behind stubs.
  */
 export const browserBuiltinPlugins: readonly GloomPlugin[] = [
-  browserGloomberbCloudPlugin,
+  gloomberbCloudPlugin,
   browserPortfolioPlugin,
   browserTickerCorePlugin,
   browserOptionsVolatilityPlugin,

package/src/plugins/catalog-cli.ts

@@ -0,0 +1,20 @@
+import type { CliCommandDef } from "../types/plugin";
+import { fearGreedPluginMeta, newsPluginMeta, notesPluginMeta, portfolioPluginMeta } from "./builtin/builtin-plugin-meta";
+import { ALERTS_PLUGIN_ID } from "./builtin/alerts/constants";
+import { alertsCliCommand } from "./builtin/alerts/cli";
+import { fearGreedCliCommand } from "./builtin/fear-greed/cli";
+import { rssCliCommand } from "./builtin/news/wire/rss/cli";
+import { notesCliCommand } from "./builtin/notes/cli";
+import { portfolioCliCommand } from "./builtin/portfolio-list/cli/portfolio-command";
+import { watchlistCliCommand } from "./builtin/portfolio-list/cli/watchlist-command";
+
+/** Command definitions shared with the plugins, without loading their pane components. */
+export function getBuiltinCliCommands(): { pluginId: string; commands: CliCommandDef[] }[] {
+  return [
+    { pluginId: portfolioPluginMeta.id, commands: [portfolioCliCommand, watchlistCliCommand] },
+    { pluginId: newsPluginMeta.id, commands: [rssCliCommand] },
+    { pluginId: notesPluginMeta.id, commands: [notesCliCommand] },
+    { pluginId: fearGreedPluginMeta.id, commands: [fearGreedCliCommand] },
+    { pluginId: ALERTS_PLUGIN_ID, commands: [alertsCliCommand] },
+  ];
+}

package/src/plugins/host-link.ts

@@ -225,6 +225,8 @@ export interface PeerLinkState {
   target: string | null;
   /** The link resolves to the sibling's folder. */
   linked: boolean;
+  /** Why reading through the link failed, when it did: it can be in place and still not lead anywhere. */
+  resolveError?: string;
   /** Links this process wrote at that path, and when it last did. */
   writes: number;
   lastWriteAt?: number;
@@ -272,11 +274,21 @@ export function describePeerLink(pluginDir: string, peer: string, pluginsDir: st
     link = stats.isSymbolicLink() ? (process.platform === "win32" ? "junction" : "symlink") : "file";
   }
   const isLinkType = link === "junction" || link === "symlink";
+  const linked = directory !== null && alreadyLinked(linkPath, join(pluginsDir, directory));
+  let resolveError: string | undefined;
+  if (isLinkType && !linked) {
+    try {
+      statSync(linkPath);
+    } catch (error) {
+      resolveError = errorCode(error);
+    }
+  }
   return {
     ...base,
     link,
     target: isLinkType ? describeTarget(linkPath, pluginsDir) : null,
-    linked: directory !== null && alreadyLinked(linkPath, join(pluginsDir, directory)),
+    linked,
+    ...(resolveError ? { resolveError } : {}),
   };
 }