@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/plugins/builtin/buildout/facilities.ts

@@ -0,0 +1,309 @@
+/**
+ * TheBuildout's facilities as a layer of the world map: data centers, fabs,
+ * power plants, mines and the plants around them, read from the dataset's own
+ * map of located sites. A map linked to TheBuildout (or to any list) shows the
+ * selected company's sites, owned or not, or every site owned by a company in
+ * the selected theme. The dataset answers with what this account may see, so
+ * a theme's sites follow the same free and Pro split as the theme's companies.
+ */
+import type {
+  GeoBbox,
+  GeoColumn,
+  GeoEntitiesPayload,
+  GeoEntityPayload,
+  GeoEntityRow,
+  GeoFeature,
+  GeoFeaturesPayload,
+  GeoLayerInfo,
+  GeoPropValue,
+} from "../../../api-client/geo";
+import type { LocalEntityQuery, LocalFeatureQuery, LocalGeoLayer } from "../world-venue-map/local-layers";
+import { createTtlCache } from "../../../data/ttl-cache";
+import { type BuildoutReader, buildoutApi, getBuildoutReader } from "./model";
+
+const FACILITIES_LAYER_ID = "facilities";
+
+interface WorldMapPoint {
+  id: string;
+  name: string;
+  type: string | null;
+  siteRoles?: string[] | null;
+  physicalForms?: string[] | null;
+  capabilities?: string[] | null;
+  countryIso?: string | null;
+  ownerCompanyId?: string | null;
+  ownerTicker?: string | null;
+  ownerName?: string | null;
+  powerCapacity?: string | null;
+  constructionActivity?: number | null;
+  relevance?: { category?: string | null; score?: number | null; tier?: string | null; reasons?: string[] | null } | null;
+  lat: number;
+  lng: number;
+  coordinateSource?: string | null;
+}
+
+interface WorldMapPayload {
+  generatedAt?: string | null;
+  points?: WorldMapPoint[];
+  scope?: { kind?: string; id?: string | null; ticker?: string | null } | null;
+}
+
+interface FacilitySet {
+  asOf: string | null;
+  rows: GeoEntityRow[];
+  byId: Map<string, { row: GeoEntityRow; point: WorldMapPoint }>;
+}
+
+const COLUMNS: GeoColumn[] = [
+  { key: "label", label: "Facility" },
+  { key: "type", label: "Type" },
+  { key: "mw", label: "MW", align: "right", format: "int" },
+  { key: "owner", label: "Owner" },
+  { key: "country", label: "Country" },
+];
+
+const INFO: GeoLayerInfo = {
+  id: FACILITIES_LAYER_ID,
+  name: "Facilities",
+  group: "infrastructure",
+  geometry: "point",
+  cadence: "daily",
+  refreshSeconds: null,
+  asOf: null,
+  count: null,
+  status: "ok",
+  access: "free",
+  columns: COLUMNS,
+  series: [],
+  defaultVisible: false,
+};
+
+/** Sites with no use to a map of the build-out: head offices and rows the dataset has not typed. */
+const LEFT_OUT = new Set(["office", ""]);
+const ALL_TTL_MS = 30 * 60_000;
+const SCOPED_TTL_MS = 10 * 60_000;
+const THEME_PAGE = 200;
+
+const TYPE_WORDS: Record<string, string> = {
+  "Manufacturing Plant": "Plant",
+  "Semiconductor Fab": "Fab",
+  "Power Station": "Power plant",
+  "Advanced Packaging": "Packaging",
+  "Energy Storage Facility": "Storage",
+  "R&D Center": "R&D",
+  "Logistics Hub": "Logistics",
+  "Transmission Line": "Transmission",
+  "Utility Network": "Utility",
+};
+
+function entityKind(type: string | null): string {
+  switch (type) {
+    case "Data Center": return "data-center";
+    case "Power Station":
+    case "Substation":
+    case "Energy Storage Facility": return "power-plant";
+    case "Semiconductor Fab":
+    case "Advanced Packaging": return "fab";
+    default: return "facility";
+  }
+}
+
+/** "300.00 MW" reads 300; a site the dataset has no figure for has none. */
+function megawatts(value: string | null | undefined): number | null {
+  const match = value?.replace(/,/g, "").match(/([\d.]+)\s*(GW|MW|KW)/i);
+  if (!match) return null;
+  const number = Number(match[1]);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  const unit = match[2]!.toUpperCase();
+  const mw = unit === "GW" ? number * 1000 : unit === "KW" ? number / 1000 : number;
+  return mw >= 10 ? Math.round(mw) : Math.round(mw * 10) / 10;
+}
+
+const PLACED_BY: Record<string, string> = { geocode: "Address", metadata: "Site record", boundary: "Traced boundary" };
+
+function toRow(point: WorldMapPoint): GeoEntityRow {
+  const ticker = point.ownerTicker?.trim();
+  return {
+    id: point.id,
+    label: point.name,
+    lon: point.lng,
+    lat: point.lat,
+    props: {
+      type: point.type ? TYPE_WORDS[point.type] ?? point.type : null,
+      mw: megawatts(point.powerCapacity),
+      owner: point.ownerName ?? null,
+      country: point.countryIso ?? null,
+    },
+    ...(ticker ? { tickers: [{ symbol: ticker, via: "owner" as const, confidence: "reviewed" as const }] } : {}),
+  };
+}
+
+/** The score the dataset gives a site for the build-out, plus a little for its size, so a capped answer keeps what matters. */
+function rank(point: WorldMapPoint): number {
+  const mw = megawatts(point.powerCapacity) ?? 0;
+  return (point.relevance?.score ?? 0) + Math.min(20, Math.log10(1 + mw) * 6);
+}
+
+function facilitySet(payload: WorldMapPayload, keep: (point: WorldMapPoint) => boolean = () => true): FacilitySet {
+  const points = (payload.points ?? []).filter((point) => (
+    Number.isFinite(point.lat) && Number.isFinite(point.lng) && !LEFT_OUT.has((point.type ?? "").toLowerCase()) && keep(point)
+  )).sort((left, right) => rank(right) - rank(left));
+  const byId = new Map<string, { row: GeoEntityRow; point: WorldMapPoint }>();
+  const rows = points.map((point) => {
+    const row = toRow(point);
+    byId.set(row.id, { row, point });
+    return row;
+  });
+  return { asOf: payload.generatedAt ?? null, rows, byId };
+}
+
+// Every entry is one reader's: the free set is the same for everyone signed
+// out or without Buildout, and a token's answer belongs to its account. A
+// sign-out, a plan that ends or one that starts reads under a new key.
+const allSites = createTtlCache<FacilitySet>({ ttlMs: ALL_TTL_MS, maxEntries: 4 });
+const scopedSites = createTtlCache<FacilitySet>({ ttlMs: SCOPED_TTL_MS, maxEntries: 64 });
+const themeCompanies = createTtlCache<Set<string>>({ ttlMs: ALL_TTL_MS, maxEntries: 64 });
+
+function readerKey(reader: BuildoutReader): string {
+  return reader.token ? `pro:${reader.account}` : "free";
+}
+
+function loadAll(reader: BuildoutReader): Promise<FacilitySet> {
+  return allSites.load(readerKey(reader), async () => facilitySet(await buildoutApi<WorldMapPayload>("/sites/world-map", reader.token)));
+}
+
+/** The company's own sites and the ones it is named at. An unknown ticker has none. */
+function loadCompany(reader: BuildoutReader, symbol: string): Promise<FacilitySet> {
+  return scopedSites.load(`${readerKey(reader)}|company:${symbol}`, async () => {
+    try {
+      return facilitySet(await buildoutApi<WorldMapPayload>(`/sites/world-map?company=${encodeURIComponent(symbol)}`, reader.token));
+    } catch (error) {
+      if (error instanceof Error && /not found|404/i.test(error.message)) return { asOf: null, rows: [], byId: new Map() };
+      throw error;
+    }
+  });
+}
+
+/** The ids of the theme's companies this account can see. */
+function loadThemeCompanies(reader: BuildoutReader, slug: string): Promise<Set<string>> {
+  return themeCompanies.load(`${readerKey(reader)}|${slug}`, async () => {
+    const ids = new Set<string>();
+    for (let offset = 0; offset < 2000; offset += THEME_PAGE) {
+      const page = await buildoutApi<{ companies?: Array<{ id?: string }> } | Array<{ id?: string }>>(
+        `/companies?list=${encodeURIComponent(slug)}&limit=${THEME_PAGE}&offset=${offset}&sort=marketCap&order=desc`,
+        reader.token,
+      );
+      const companies = Array.isArray(page) ? page : page.companies ?? [];
+      for (const company of companies) if (company.id) ids.add(company.id);
+      if (companies.length < THEME_PAGE) break;
+    }
+    return ids;
+  });
+}
+
+async function loadScope(scope: string | null): Promise<FacilitySet> {
+  const reader = await getBuildoutReader();
+  if (scope?.startsWith("company:")) return loadCompany(reader, scope.slice("company:".length));
+  if (scope?.startsWith("theme:")) {
+    const slug = scope.slice("theme:".length);
+    return scopedSites.load(`${readerKey(reader)}|${scope}`, async () => {
+      const [all, ids] = await Promise.all([loadAll(reader), loadThemeCompanies(reader, slug)]);
+      return {
+        asOf: all.asOf,
+        rows: all.rows.filter((row) => ids.has(all.byId.get(row.id)?.point.ownerCompanyId ?? "")),
+        byId: all.byId,
+      };
+    });
+  }
+  return loadAll(reader);
+}
+
+function inBbox(row: GeoEntityRow, bbox: GeoBbox | null): boolean {
+  if (!bbox) return true;
+  const [west, south, east, north] = bbox;
+  if (row.lat < south || row.lat > north) return false;
+  return west <= east ? row.lon >= west && row.lon <= east : row.lon >= west || row.lon <= east;
+}
+
+function feature(row: GeoEntityRow, point: WorldMapPoint): GeoFeature {
+  return {
+    id: row.id,
+    layer: FACILITIES_LAYER_ID,
+    entityKind: entityKind(point.type),
+    label: row.label,
+    geometry: { type: "Point", coordinates: [row.lon, row.lat] },
+    ts: null,
+    props: row.props,
+    ...(row.tickers ? { tickers: row.tickers } : {}),
+  };
+}
+
+function matches(row: GeoEntityRow, needle: string): boolean {
+  if (!needle) return true;
+  const symbol = needle.replace(/^\$/, "").toUpperCase();
+  if (row.tickers?.some((link) => link.symbol.toUpperCase() === symbol)) return true;
+  return [row.label, ...Object.values(row.props)].some((value) => typeof value === "string" && value.toLowerCase().includes(needle));
+}
+
+function compare(key: string | null, dir: "asc" | "desc") {
+  const sign = dir === "asc" ? 1 : -1;
+  return (left: GeoEntityRow, right: GeoEntityRow) => {
+    if (!key) return 0;
+    const a: GeoPropValue = key === "label" ? left.label : left.props[key] ?? null;
+    const b: GeoPropValue = key === "label" ? right.label : right.props[key] ?? null;
+    // Missing values sink in either direction.
+    if (a === null || b === null) return a === b ? 0 : a === null ? 1 : -1;
+    if (typeof a === "number" && typeof b === "number") return (a - b) * sign;
+    return String(a).localeCompare(String(b)) * sign;
+  };
+}
+
+const PLAIN_LIST = (values: string[] | null | undefined, count = 6) => (values?.length ? values.slice(0, count).join(", ") : null);
+
+export const facilitiesLayer: LocalGeoLayer = {
+  info: INFO,
+  async features(query: LocalFeatureQuery): Promise<GeoFeaturesPayload> {
+    const set = await loadScope(query.scope);
+    const inView = set.rows.filter((row) => inBbox(row, query.bbox));
+    const kept = inView.slice(0, query.limit);
+    return {
+      layer: FACILITIES_LAYER_ID,
+      asOf: set.asOf,
+      features: kept.map((row) => feature(row, set.byId.get(row.id)!.point)),
+      total: inView.length,
+      truncated: kept.length < inView.length,
+    };
+  },
+  async entities(query: LocalEntityQuery): Promise<GeoEntitiesPayload> {
+    const set = await loadScope(query.scope);
+    const needle = query.q.trim().toLowerCase();
+    const rows = set.rows.filter((row) => inBbox(row, query.bbox) && matches(row, needle));
+    const sorted = query.sort ? [...rows].sort(compare(query.sort, query.dir)) : rows;
+    return {
+      layer: FACILITIES_LAYER_ID,
+      asOf: set.asOf,
+      columns: COLUMNS,
+      rows: sorted.slice(query.offset, query.offset + query.limit),
+      total: rows.length,
+    };
+  },
+  async entity(id: string, scope: string | null): Promise<GeoEntityPayload> {
+    const set = await loadScope(scope);
+    const found = set.byId.get(id) ?? (await loadAll(await getBuildoutReader())).byId.get(id);
+    if (!found) throw new Error("Unknown facility");
+    const { row, point } = found;
+    const relevance = point.relevance?.tier
+      ? `${point.relevance.tier.charAt(0).toUpperCase()}${point.relevance.tier.slice(1)}${point.relevance.reasons?.length ? `: ${point.relevance.reasons.join(", ")}` : ""}`
+      : null;
+    return {
+      feature: feature(row, point),
+      detail: {
+        roles: PLAIN_LIST(point.siteRoles),
+        forms: PLAIN_LIST(point.physicalForms),
+        capabilities: PLAIN_LIST(point.capabilities),
+        relevance,
+        placedBy: point.coordinateSource ? PLACED_BY[point.coordinateSource] ?? null : null,
+      },
+    };
+  },
+};

package/src/plugins/builtin/buildout/format.ts

@@ -127,6 +127,15 @@ export function criticalityColor(value: string | null | undefined) {
   }
 }
 
+/** A theme's tiers, most important first. */
+export const LIST_TIER_ORDER: readonly string[] = ["leader", "major", "notable", "watchlist"];
+
+/** `core_vendor` reads "Core vendor". */
+export function listWord(value: string | null | undefined): string | null {
+  const words = value?.trim().replace(/[_-]+/g, " ").toLowerCase();
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : null;
+}
+
 export function tickerSymbol(value: string | null | undefined): string | null {
   const symbol = value?.trim();
   return symbol ? symbol.toUpperCase() : null;

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

@@ -1,24 +1,70 @@
-import { BuildoutPane } from "./pane";
+import { BUILDOUT_COMPANY_PANE_ID } from "./company/id";
 import type { PluginModule } from "../plugin-module";
+import type { PaneReportOptionDef } from "../../../types/plugin";
+import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
+
+let removeFacilities: (() => void) | null = null;
+
+/** Which view the company pane opens on: a desk opens one on its signals. */
+const COMPANY_TAB_OPTION: PaneReportOptionDef = {
+  key: "tab",
+  type: "enum",
+  description: "The view to open on: the flow of deals, suppliers and customers, the sites, hiring by site or the signals.",
+  values: [{ value: "flow" }, { value: "sites" }, { value: "hiring" }, { value: "signals" }],
+  example: "--tab signals",
+};
 
 export const buildoutModule: PluginModule = {
+  // Facilities join the world map's layers for as long as the plugin is on.
+  setup() {
+    const { facilitiesLayer } = require("./facilities") as typeof import("./facilities");
+    const { registerLocalGeoLayer } = require("../world-venue-map/local-layers") as typeof import("../world-venue-map/local-layers");
+    removeFacilities?.();
+    removeFacilities = registerLocalGeoLayer(facilitiesLayer);
+  },
+  dispose() {
+    removeFacilities?.();
+    removeFacilities = null;
+  },
   panes: [{
     id: "buildout",
     reportFreshness: { status: "not-a-feed", basis: "infrastructure research" },
     name: "TheBuildout",
     icon: "T",
-    component: BuildoutPane,
+    get component(): typeof import("./pane").BuildoutPane { const { BuildoutPane } = require("./pane"); return BuildoutPane; },
     defaultPosition: "right",
     defaultMode: "floating",
     defaultFloatingSize: { width: 110, height: 34 },
+    // The company under the cursor, for linked panes: its flow, a chart, a map of its sites.
+    tickerSource: true,
+  }, {
+    id: BUILDOUT_COMPANY_PANE_ID,
+    reportFreshness: { status: "not-a-feed", basis: "disclosed relationships" },
+    // Short, since a linked pane's title adds the ticker and what it follows.
+    name: "Buildout",
+    icon: "T",
+    get component(): typeof import("./company/pane").BuildoutCompanyPane { const { BuildoutCompanyPane } = require("./company/pane"); return BuildoutCompanyPane; },
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 120, height: 32 },
+    tickerFollower: true,
+    instruments: ["equity"],
+    reportOptions: [COMPANY_TAB_OPTION],
   }],
   paneTemplates: [{
     id: "buildout-pane",
     paneId: "buildout",
     label: "TheBuildout",
-    description: "Open TheBuildout infrastructure intelligence.",
-    keywords: ["tbo", "buildout", "thebuildout", "infrastructure", "sites", "intel"],
+    description: "Open TheBuildout infrastructure intelligence: themes, companies, sites and intel.",
+    keywords: ["tbo", "buildout", "thebuildout", "infrastructure", "themes", "sites", "intel"],
     shortcut: { prefix: "TBO" },
     createInstance: () => ({ placement: "floating" }),
-  }],
+  }, createTickerSurfacePaneTemplate({
+    id: "buildout-company-pane",
+    paneId: BUILDOUT_COMPANY_PANE_ID,
+    label: "TheBuildout Company",
+    description: "One company in TheBuildout: its power and hosting deals, suppliers and customers as a flow, its sites, hiring by site and the signals that name it.",
+    keywords: ["tboc", "buildout", "thebuildout", "power deals", "data centers", "sites", "suppliers", "customers", "signals"],
+    shortcut: "TBOC",
+  })],
 };

package/src/plugins/builtin/buildout/model/index.ts

@@ -1,4 +1,5 @@
 import { apiClient } from "../../../../api-client";
+import { createTtlCache } from "../../../../data/ttl-cache";
 import { httpFetch } from "../../../../utils/http-transport";
 import { logFailure } from "../../../../utils/log-failure";
 import type {
@@ -119,26 +120,77 @@ export async function loadBuildoutData(token: string | null) {
     access,
     token,
     lists,
-    companies: { ...emptyPage<BuildoutCompany>(), blurredCompanyCount: 0 },
+    companies: { ...emptyPage<BuildoutCompany>(), blurredCompanyCount: 0, listSlug: null },
     sites: pageFromItems(sites),
     intel: pageFromItems(intel),
   };
 }
 
-export async function getBuildoutProToken() {
-  if (!apiClient.isSignedIn()) return null;
+/** What the dataset is read with: a Buildout token, or none for the free set. */
+interface BuildoutGrant {
+  token: string | null;
+  expiresAtMs: number | null;
+}
 
-  try {
-    const session = await apiClient.getSession();
-    if (!session) return null;
+/** Whose reads these are: the signed-in account, and its token when it has Buildout. */
+export interface BuildoutReader {
+  account: string | null;
+  token: string | null;
+}
+
+const NO_GRANT: BuildoutGrant = { token: null, expiresAtMs: null };
+/** A token is asked for again this long before it lapses. */
+const TOKEN_RENEW_EARLY_MS = 60_000;
+/** A token whose answer carries no expiry is kept this long. */
+const TOKEN_FALLBACK_MS = 5 * 60_000;
+/** An account without Buildout is asked again after this long, so a new plan shows within a minute. */
+const NO_PLAN_MS = 60_000;
+
+/**
+ * One account's grant, shared by every pane and the facilities layer: asking
+ * costs three account requests (one issues a token), and a linked desk asks
+ * on every company the cursor passes.
+ */
+const grants = createTtlCache<BuildoutGrant>({
+  ttlMs: (grant) => {
+    if (!grant.token) return NO_PLAN_MS;
+    if (grant.expiresAtMs === null) return TOKEN_FALLBACK_MS;
+    return Math.max(0, grant.expiresAtMs - Date.now() - TOKEN_RENEW_EARLY_MS);
+  },
+  maxEntries: 4,
+});
+
+async function issueGrant(checkSession: boolean): Promise<BuildoutGrant> {
+  if (checkSession && !(await apiClient.getSession())) return NO_GRANT;
+  const account = await apiClient.getBuildoutAccount();
+  if (!account?.subscription.active) return NO_GRANT;
+  const issued = await apiClient.getBuildoutToken();
+  if (!issued?.token) return NO_GRANT;
+  const expiresAtMs = Date.parse(issued.expiresAt);
+  return { token: issued.token, expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : null };
+}
 
-    const account = await apiClient.getBuildoutAccount();
-    if (!account?.subscription.active) return null;
+/**
+ * The account reading the dataset and its token. A token is reused until a
+ * minute before it lapses; `fresh` asks again, for a refresh the user pressed.
+ * Signed out there is no account and no token, at once.
+ */
+export async function getBuildoutReader({ fresh = false }: { fresh?: boolean } = {}): Promise<BuildoutReader> {
+  if (!apiClient.isSignedIn()) return { account: null, token: null };
 
-    const token = await apiClient.getBuildoutToken();
-    return token?.token ?? null;
+  try {
+    // A user restored from the last run still has its session checked before a token is issued.
+    const restored = apiClient.getCurrentUser();
+    const user = restored ?? await apiClient.getSession();
+    if (!user) return { account: null, token: null };
+    const grant = await grants.load(user.id, () => issueGrant(restored !== null), { force: fresh });
+    return { account: user.id, token: grant.token };
   } catch (error) {
     logFailure("buildout.model", "Check access failed")(error);
     throw new Error("Access check failed. Access is unknown.");
   }
 }
+
+export async function getBuildoutProToken(options?: { fresh?: boolean }) {
+  return (await getBuildoutReader(options)).token;
+}

package/src/plugins/builtin/buildout/model/normalizers.ts

@@ -121,6 +121,9 @@ export function normalizeList(raw: RawObject): BuildoutList {
     avgSectorGrowth: stringField(raw, "avgSectorGrowth", "avg_sector_growth"),
     avgReturn1y: stringField(raw, "avgReturn1y", "avg_return_1y"),
     avgMargin: stringField(raw, "avgMargin", "avg_margin"),
+    leaders: raw.importanceCounts && typeof raw.importanceCounts === "object"
+      ? numberField(raw.importanceCounts as RawObject, "leader")
+      : null,
   };
 }
 
@@ -256,6 +259,8 @@ function readCompany(raw: RawObject): BuildoutCompany {
     logoUrl: stringField(raw, "logoUrl", "logo_url"),
     researchReport: stringField(raw, "researchReport", "research_report"),
     listReason: stringField(raw, "listReason", "list_reason"),
+    listRole: stringField(raw, "listCategoryRole", "list_category_role"),
+    listTier: stringField(raw, "listCategoryImportance", "list_category_importance"),
     intelligence: arrayField(raw, "intelligence").map((item) => ({
       publishedAt: stringField(item, "publishedAt", "published_at"),
       headline: stringField(item, "headline", "title"),

package/src/plugins/builtin/buildout/model/types.ts

@@ -1,6 +1,6 @@
 import type { DataTableColumn } from "../../../../components";
 
-export type BuildoutTabId = "companies" | "sites" | "intel";
+export type BuildoutTabId = "themes" | "companies" | "sites" | "intel";
 export type BuildoutAccess = "free" | "pro";
 
 export type RawObject = Record<string, unknown>;
@@ -40,6 +40,8 @@ export type BuildoutList = {
   avgSectorGrowth?: string | null;
   avgReturn1y?: string | null;
   avgMargin?: string | null;
+  /** Companies the theme ranks as its leaders. */
+  leaders?: number | null;
 };
 
 export type BuildoutCompany = {
@@ -135,6 +137,10 @@ export type BuildoutCompany = {
   logoUrl?: string | null;
   researchReport?: string | null;
   listReason?: string | null;
+  /** Its part in the open theme: core vendor, integrator... */
+  listRole?: string | null;
+  /** How much it matters to the open theme: leader, major, notable, watchlist. */
+  listTier?: string | null;
   intelligence?: Array<{
     publishedAt?: string | null;
     headline?: string | null;
@@ -267,7 +273,8 @@ export type BuildoutLoadState =
     access: BuildoutAccess;
     token: string | null;
     lists: BuildoutList[];
-    companies: BuildoutPagedState<BuildoutCompany> & { blurredCompanyCount: number };
+    /** The companies of one list: `listSlug`, or none yet. */
+    companies: BuildoutPagedState<BuildoutCompany> & { blurredCompanyCount: number; listSlug: string | null };
     sites: BuildoutPagedState<BuildoutSite>;
     intel: BuildoutPagedState<BuildoutUpdate>;
     loadedAt: number;
@@ -299,6 +306,8 @@ export type BuildoutColumnId =
   | "dividendYield"
   | "return1y"
   | "employees"
+  | "listRole"
+  | "listTier"
   | "site"
   | "type"
   | "owner"