@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/plugins/builtin/volatility/headless.ts

@@ -2,6 +2,7 @@ import type { HeadlessBundleResult, HeadlessPaneContext, HeadlessPaneDefinition,
 import { createVolatilityDependencies, loadVolatilityData, type VolatilityLoadResult } from "./client";
 import { termStateLabel, type VolatilityData } from "./model";
 import { newestReportTime, oldestReportTime } from "../../../utils/utc-time";
+import { servedFromSavedCopy } from "../../../data/saved-copies";
 
 function formattedValue(value: unknown): string { return typeof value === "number" && Number.isFinite(value) ? value.toFixed(2) : "--"; }
 function formattedPercentile(value: unknown): string { return typeof value === "number" && Number.isFinite(value) ? value.toFixed(0) : "--"; }
@@ -60,6 +61,8 @@ export function createVolatilityHeadless(dependencies: VolatilityHeadlessDepende
     async load(args, context) {
       const result = await dependencies.load(args, context);
       context.signal.throwIfAborted();
+      // A saved copy answering a failed refresh ends the report with when it was saved.
+      const savedCopy = <T>(value: T) => result.savedAt != null ? servedFromSavedCopy(value, result.savedAt) : value;
       // Daily index closes, dated by the newest index on the board; a sparse index shows as the oldest.
       const boardDates = result.data.board.filter((row) => row.value != null).map((row) => row.date);
       const freshness = { source: "Cboe and FRED", status: "not-a-feed" as const, basis: "daily index closes", cadence: "daily" as const,
@@ -67,10 +70,10 @@ export function createVolatilityHeadless(dependencies: VolatilityHeadlessDepende
       return { ...projectVolatilityHeadless(result.data), freshness, errors: result.errors,
         complete: result.phase === "ready" && !result.stale && result.data.warnings.length === 0,
         unavailableSymbols: result.data.board.filter((row) => row.value == null).map((row) => row.symbol),
-        metadata: { stale: result.stale, phase: result.phase, loaded: result.loaded, total: result.total,
+        metadata: savedCopy({ stale: result.stale, phase: result.phase, loaded: result.loaded, total: result.total,
           data: result.data, unit: "index points", observations: "daily history or isolated index observation",
           percentile: "Midrank within last calendar year; at least 200 observations spanning 300 days",
-          vixFuturesAvailable: false, methodology: "docs/research-data.md#vix-curve-and-cross-asset-volatility-board" },
+          vixFuturesAvailable: false, methodology: "docs/research-data.md#vix-curve-and-cross-asset-volatility-board" }),
       };
     },
   };

package/src/plugins/builtin/volatility/index.tsx

@@ -1,13 +1,12 @@
 import type { PluginModule } from "../plugin-module";
 import { volatilityHeadless } from "./headless";
-import { VolatilityPane } from "./pane";
 import { VOLATILITY_SERIES } from "./series";
 
 
 export const volatilityModule: PluginModule = {
   series: VOLATILITY_SERIES,
   panes: [{
-    id: "volatility-term-structure", name: "Volatility", icon: "V", component: VolatilityPane,
+    id: "volatility-term-structure", name: "Volatility", icon: "V", get component(): typeof import("./pane").VolatilityPane { const { VolatilityPane } = require("./pane"); return VolatilityPane; },
     defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 110, height: 34 },
     tableExport: true, headless: volatilityHeadless,
   }],

package/src/plugins/builtin/volatility/model.ts

@@ -30,6 +30,11 @@ export interface VolatilityHistoryInput {
   stale?: boolean;
   error?: string | null;
   fetchedAt?: number | null;
+  /**
+   * When the copy shown was saved, when a failed refresh left it answering:
+   * the pane's footer says "saved copy from …" instead of the failure.
+   */
+  savedAt?: number | null;
 }
 export interface VolatilitySeriesInput {
   observations: CloudFredObservationPayload[];
@@ -37,6 +42,8 @@ export interface VolatilitySeriesInput {
   stale?: boolean;
   error?: string | null;
   fetchedAt?: number | null;
+  /** As `VolatilityHistoryInput.savedAt`. */
+  savedAt?: number | null;
 }
 export interface VolatilityInputs {
   history?: Partial<Record<VolatilityIndexId, VolatilityHistoryInput>>;
@@ -131,6 +138,8 @@ export interface VolatilityBoardRow {
   status: "available" | "limited" | "unavailable";
   stale: boolean;
   error: string | null;
+  /** When the copy shown was saved, when a failed refresh left it answering. */
+  savedAt?: number;
   warnings: string[];
 }
 export interface VolatilityData {
@@ -233,8 +242,9 @@ function fredHistory(inputs: VolatilityInputs["fred"]): FredVolatilityHistory {
     const input = inputs?.[definition.seriesId];
     const normalized = normalizeHistory(input?.observations ?? [], true);
     warnings.push(...normalized.warnings.map((warning) => `${definition.seriesId}: ${warning}`));
-    if (input?.error) warnings.push(`${definition.seriesId}: ${input.error}`);
-    if (input?.stale) warnings.push(`${definition.seriesId}: cached source is stale`);
+    // A saved copy is dated in the footer; its failed refresh is not repeated here.
+    if (input?.error && input.savedAt == null) warnings.push(`${definition.seriesId}: ${input.error}`);
+    if (input?.stale && input.savedAt == null) warnings.push(`${definition.seriesId}: cached source is stale`);
     const latest = normalized.history.at(-1);
     return { ...definition, title: input?.info?.title ?? definition.label, value: latest?.value ?? null,
       date: latest?.date ?? null, history: normalized.history,
@@ -300,15 +310,16 @@ function boardRow(definition: typeof VOLATILITY_INDICES[number], input: Volatili
   if (latest && latest.date !== normalized.rows.at(-1)?.date) warnings.push("Latest supplied close unavailable; showing last valid observation");
   if (latest && !adjacent) warnings.push("1D change unavailable: previous daily close missing or too far apart");
   if (latest && !broadCoverage) warnings.push(`1Y percentile unavailable: ${history.length} observations across ${coverageDays} days`);
-  if (input?.stale) warnings.push("Cached daily history is stale");
-  if (input?.error) warnings.push(input.error);
+  // A saved copy is dated in the footer; its failed refresh is not repeated here.
+  if (input?.stale && input.savedAt == null) warnings.push("Cached daily history is stale");
+  if (input?.error && input.savedAt == null) warnings.push(input.error);
   return { ...definition, unit: "index points", value: latest?.value ?? null, date: latest?.date ?? null,
     source: input?.source ?? null, previousDate: previous?.date ?? null, change1d,
     change1dPercent: change1d != null ? change1d / previous!.value! * 100 : null,
     percentile1y, sampleSize: history.length, coverageDays, history,
     missingDates: normalized.rows.filter((row) => row.value == null && Date.parse(row.date) > cutoff).map((row) => row.date),
     status: !latest ? "unavailable" : warnings.length > 0 ? "limited" : "available",
-    stale: input?.stale ?? false, error: input?.error ?? null, warnings };
+    stale: input?.stale ?? false, error: input?.error ?? null, ...(input?.savedAt != null ? { savedAt: input.savedAt } : {}), warnings };
 }
 function alignedCurve(board: readonly VolatilityBoardRow[], fred: FredVolatilityHistory, term: VolatilityTermHistory): VolatilityCurve {
   const rows = VOLATILITY_CURVE_INDICES.map((definition) => board.find((row) => row.id === definition.id)!);
@@ -337,7 +348,7 @@ function alignedCurve(board: readonly VolatilityBoardRow[], fred: FredVolatility
   const spot = points[1]!.value, threeMonth = points[2]!.value;
   const warnings = points.flatMap((point, index) => [
     ...(point.value == null ? [`${point.label}: no close aligned to ${date ?? "a common date"}`] : []),
-    ...(point.value != null && rows[index]!.stale ? [`${point.label}: aligned close is from stale cached history`] : []),
+    ...(point.value != null && rows[index]!.stale && rows[index]!.savedAt == null ? [`${point.label}: aligned close is from stale cached history`] : []),
   ]);
   const ratio = spot != null && threeMonth != null ? threeMonth / spot : null;
   const context = ratioPercentile(term, ratio, date);

package/src/plugins/builtin/volatility/pane.tsx

@@ -2,6 +2,8 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ChartTableHeader, CurveSurface, curveGhostColors, DataTableView, formatPercentAxis, PaneStatusBody, useChartTableSelection,
   usePaneFooter, usePaneNoticeFooter, usePaneTabs, type DataTableColumn, type StatItem } from "../../../components";
 import { curveStrip, curveSurfaceMinRows } from "../../../components/chart/curve";
+import { savedCopyFooterInfo } from "../../../components/layout/pane/footer";
+import { STALE_SEGMENT } from "../../../components/layout/pane/status-footer";
 import { dropColumnsToFit } from "../../../components/ui/table-layout";
 import { useAsyncResource } from "../../../react/async-resource";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
@@ -170,13 +172,15 @@ export function VolatilityPane({ focused, width, height }: PaneProps) {
   const observationBasis = intraday ? "intraday" : sparse ? "observation" : settled ? "close" : DAY_SO_FAR_TEXT;
   usePaneFooter("volatility", () => ({ info: [
     ...(resource.loading ? [{ id: "loading", parts: [{ text: "loading volatility", tone: "muted" as const }] }] : []),
-    ...(result?.stale ? [{ id: "stale", parts: [{ text: "stale", tone: "warning" as const }] }] : []),
+    // A saved copy answering a failed refresh says when it was saved; other stale closes say only that.
+    ...savedCopyFooterInfo([result?.savedAt]),
+    ...(result?.stale && result.savedAt == null ? [STALE_SEGMENT] : []),
     // One fact, "close 2026-09-25": the basis and its date read as one segment.
     ...(data || asOf ? [{ id: "basis", parts: [
       ...(data ? [{ text: observationBasis, tone: "muted" as const }] : []),
       ...(asOf ? [{ text: observationTime ? `${observationTime.slice(0, 16).replace("T", " ")} UTC` : asOf, tone: "muted" as const }] : []),
     ] }] : []),
-  ], hints: [{ id: "view", key: "v", label: "iew", onPress: cycleTab }] }), [resource.loading, result?.stale, data, asOf, observationTime, observationBasis, cycleTab]);
+  ], hints: [{ id: "view", key: "v", label: "iew", onPress: cycleTab }] }), [resource.loading, result?.stale, result?.savedAt, data, asOf, observationTime, observationBasis, cycleTab]);
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: TABS, activeValue: tab, onSelect: setTab, focused, dense: true });
   const contentHeight = Math.max(5, height - tabRows);
   // The board needs only its rows; the selected index history takes the rest.

package/src/plugins/builtin/volatility/series.ts

@@ -105,11 +105,12 @@ export const VOLATILITY_SERIES: readonly SeriesDefinition[] = [
     tags: ["term structure", "contango", "backwardation", "VIX"],
     description: "VIX 3M over VIX on each date both closed, from Cboe's daily closes and FRED's before them; above 1 is contango.",
     load: async ({ start, signal }) => {
-      const { term, warning } = await loadVolatilityTermHistory({ ...(start ? { start } : {}), ...(signal ? { signal } : {}) });
+      const { term, warning, savedAt } = await loadVolatilityTermHistory({ ...(start ? { start } : {}), ...(signal ? { signal } : {}) });
       const attribution = termAttribution(term);
       return {
         points: term.ratioHistory.map((point) => ({ date: point.date, value: point.value })),
         ...(warning ? { warning } : {}),
+        ...(savedAt != null ? { savedAt } : {}),
         ...(attribution ? { attribution } : {}),
       };
     },

package/src/plugins/builtin/world-indices/footer.ts

@@ -1,7 +1,9 @@
 import { usePaneFooter, type PaneFooterSegment } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { useQuoteDelayFooter } from "../shared/cloud-upgrade";
 import {
   boardErrorMessage,
+  boardQuotes,
   quoteBoardFooterInfo,
   quoteBoardStatus,
   type BoardQuoteMap,
@@ -12,14 +14,17 @@ export function useWorldIndicesFooter(quotes: BoardQuoteMap, onRefresh: () => vo
   const errorMessage = boardErrorMessage(quotes);
 
   usePaneRefreshKey(onRefresh, { focused });
+  // Signed out or free, the indices' quotes are delayed ones.
+  const quoteDelay = useQuoteDelayFooter(boardQuotes(quotes), "indices-delay");
 
   usePaneFooter(
     "world-indices",
     () => {
       const info: PaneFooterSegment[] = quoteBoardFooterInfo(status);
       if (errorMessage) info.push({ id: "reason", parts: [{ text: errorMessage, tone: "warning" }] });
+      if (quoteDelay) info.push(quoteDelay);
       return { info };
     },
-    [errorMessage, focused, onRefresh, status.latestTs, status.loading, status.savedAt, status.stale, status.unavailable],
+    [errorMessage, focused, onRefresh, quoteDelay, status.latestTs, status.loading, status.savedAt, status.stale, status.unavailable],
   );
 }

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

@@ -10,11 +10,20 @@ import {
   type GeoLayersPayload,
   type GeoRequest,
 } from "../../../api-client/geo";
+import { withLocalGeoLayers } from "./local-layers";
 
 export const ENTITY_PAGE_SIZE = 100;
 
 /** Requests under /cloud/geo/ through the shared client, resolved late so tests can stub it. */
-export const cloudGeoRequest: GeoRequest = (path, init) => apiClient.geo(path, init);
+const serverGeoRequest: GeoRequest = (path, init) => apiClient.geo(path, init);
+
+/** The server's layers and the app's own (`local-layers.ts`). */
+export const cloudGeoRequest: GeoRequest = withLocalGeoLayers(serverGeoRequest);
+
+/** The same, with the app's own layers narrowed to what a linked pane selects. */
+export function scopedGeoRequest(scope: string | null): GeoRequest {
+  return scope ? withLocalGeoLayers(serverGeoRequest, scope) : cloudGeoRequest;
+}
 
 export async function loadWorldVenues(): Promise<CloudWorldVenueMapPayload> {
   const response = await apiClient.getCloudWorldVenues();

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

@@ -9,6 +9,7 @@ import { CHOKEPOINT_SERIES, createGeoChartSeriesCapability } from "./geo-series"
 import { mapHeadless } from "./headless";
 import { buildMapSettingsDef, groupTitle, MAP_PRESET_OPTIONS, parseMapPreset } from "./layers";
 import { WORLD_VENUE_MAP_PANE_ID, WorldVenueMapPane } from "./pane";
+import { mapFollowsTicker } from "./scope";
 
 const chartComposerHeadless = chartHeadless("chart-composer-pane");
 
@@ -33,6 +34,7 @@ const chokepointTemplate: PaneTemplateDef = {
   keywords: ["chokepoint", "chokepoints", "transits", "suez", "panama", "hormuz", "malacca", "shipping", "strait", "canal"],
   shortcut: { prefix: "CHOKE", argPlaceholder: "chokepoint", argKind: "text", argOptional: true },
   canCreate: () => true,
+  catalogSettings: {},
   createInstance: (_context, options) => createChokepointInstance(cloudGeoRequest, options?.arg),
 };
 
@@ -46,6 +48,8 @@ export const worldVenueMapModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 124, height: 36 },
+      // Linked to a list, a map with the app's own layers (facilities) shows the selected company's.
+      tickerFollower: mapFollowsTicker,
       // The layer picker comes from the server's catalog; without one the pane keeps its old settings.
       settings: (context) => buildMapSettingsDef(context.settings, peekGeoCatalog()?.layers) ?? { fields: [] },
     },
@@ -55,8 +59,8 @@ export const worldVenueMapModule: PluginModule = {
       id: "world-venue-map-pane",
       paneId: WORLD_VENUE_MAP_PANE_ID,
       label: "World Map",
-      description: "A world map with trading venues and their hours; ships, ports, energy and airports as layers.",
-      keywords: ["world", "map", "globe", "countries", "venue", "venues", "exchange", "mic", "market hours", "open markets", "ships", "ship", "vessels", "vessel", "shipping", "ais", "ports", "port", "chokepoints", "pipelines", "airports", "energy", "layers"],
+      description: "A world map with trading venues and their hours; ships, ports, energy, airports and AI buildout facilities as layers.",
+      keywords: ["world", "map", "globe", "countries", "venue", "venues", "exchange", "mic", "market hours", "open markets", "ships", "ship", "vessels", "vessel", "shipping", "ais", "ports", "port", "chokepoints", "pipelines", "airports", "energy", "facilities", "data centers", "fabs", "layers"],
       shortcut: {
         prefix: "MAP",
         argPlaceholder: "layers",

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]);