@skyhook-io/radar-app 1.17.0 → 1.17.1

package/src/components/capacity/CapacityView.test.tsx

@@ -1,5 +1,8 @@
+// @vitest-environment jsdom
 import { describe, expect, it, vi } from "vitest";
 import { renderToString } from "react-dom/server";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
 import { MemoryRouter } from "react-router-dom";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import type {
@@ -1337,6 +1340,326 @@ describe("CapacityView overview", () => {
   });
 });
 
+describe("Capacity scale-down observations", () => {
+  const noCandidatesExplanation =
+    "The autoscaler found no node it can remove. Usually every node is above its utilization threshold, or pods on emptier nodes can't move (PodDisruptionBudgets, local storage, kube-system pods, safe-to-evict annotations). A node's drain plan shows what would block it.";
+  const candidateExplanation =
+    "Scale-down candidates are observations, not guaranteed removals. PodDisruptionBudgets, local storage, kube-system pods, or safe-to-evict annotations can block removal. Radar can't tell which nodes the autoscaler picked, but a node's drain plan shows what would block removing it.";
+
+  function renderScaleDown(child: CapacityAutoscalerChildObservation) {
+    return renderCapacity("/capacity", (client) =>
+      client.setQueryData(["capacity", "overview"], {
+        ...comprehensiveOverview(),
+        groups: [
+          {
+            ...gkeGroup,
+            scaling: [
+              {
+                code: "at_min_size",
+                summary: "at minimum size — can't scale down",
+              },
+            ],
+            children: [child],
+            childrenMeta: boundedMeta(1),
+          },
+        ],
+        orphanAutoscalerGroups: [child],
+      }),
+    );
+  }
+
+  it("explains the floor and keeps published zero candidates", () => {
+    const clock = vi.spyOn(Date, "now").mockReturnValue(Date.parse(generatedAt) + 6 * 60 * 1000);
+    const html = renderScaleDown({
+      ...gkeChild,
+      scaleDown: {
+        status: "NoCandidates",
+        candidates: 0,
+        lastTransitionTime: generatedAt,
+        asOf: generatedAt,
+      },
+    });
+    clock.mockRestore();
+    expect(html).toContain("at minimum size");
+    expect(html).toContain(
+      "Every observed autoscaler group has its target at its published minimum.",
+    );
+    expect(html).toContain(
+      "Lowering the pool's minimum is required for it to shrink below this size.",
+    );
+    expect(html).not.toContain("No node can be removed right now");
+    expect(html).toContain(noCandidatesExplanation.replaceAll("'", "'"));
+    expect(html).not.toContain("autoscaler child");
+    expect(html).toContain("No scale-down candidates");
+    expect(html).toContain("Candidate count published by the autoscaler: 0.");
+    expect(html).not.toContain("Candidates:");
+    expect(html).toContain("Status since");
+    expect(html).toContain("(for 6m)");
+    expect(html).not.toContain("As of");
+    expect(html).toContain("PodDisruptionBudgets");
+    expect(html).not.toContain("ETA");
+  });
+
+  it("explains no candidates above the minimum on the collapsed pool and both child tables", () => {
+    const child: CapacityAutoscalerChildObservation = {
+      ...gkeChild,
+      scaleDown: { status: "NoCandidates", candidates: 0 },
+    };
+    const html = renderCapacity("/capacity", (client) =>
+      client.setQueryData(["capacity", "overview"], {
+        ...comprehensiveOverview(),
+        groups: [{ ...gkeGroup, children: [child], childrenMeta: boundedMeta(1) }],
+        orphanAutoscalerGroups: [child],
+      }),
+    );
+    expect(html).toContain('aria-expanded="false"');
+    const explanation = noCandidatesExplanation.replaceAll("'", "'");
+    expect(html).toContain(
+      `tabindex="0" role="note" aria-label="No node can be removed right now. ${explanation}"`,
+    );
+    expect(html.split(`No scale-down candidates. ${explanation}`)).toHaveLength(3);
+    expect(html).not.toContain("Scale-down candidates are observations");
+  });
+
+  it.each([
+    ["missing count", { scaleDown: { status: "NoCandidates" } }, false],
+    ["missing observation", { scaleDown: undefined }, false],
+    ["candidates present", { scaleDown: { status: "CandidatesPresent", candidates: 1 } }, false],
+    ["missing minimum", { minSize: undefined }, false],
+    ["missing target", { target: undefined }, false],
+    ["below the minimum", { target: -1 }, false],
+    ["truncated children", {}, true],
+  ])("does not assert no removable nodes with %s", (_label, override, truncated) => {
+    const html = renderCapacity("/capacity", (client) =>
+      client.setQueryData(["capacity", "overview"], {
+        ...comprehensiveOverview(),
+        groups: [{
+          ...gkeGroup,
+          children: [
+            { ...gkeChild, scaleDown: { status: "NoCandidates", candidates: 0 } },
+            { ...gkeChildBackoff, scaleDown: { status: "NoCandidates", candidates: 0 }, ...override },
+          ],
+          childrenMeta: { total: truncated ? 3 : 2, returned: 2, truncated },
+        }],
+      }),
+    );
+    expect(html).not.toContain("No node can be removed right now");
+  });
+
+  it("keeps scale-down probe freshness separate from health in both tables", () => {
+    const clock = vi
+      .spyOn(Date, "now")
+      .mockReturnValue(Date.parse(generatedAt) + 6 * 60 * 1000);
+    try {
+      const html = renderScaleDown({
+        ...gkeChild,
+        scaleDown: {
+          status: "InProgress",
+          asOf: "2026-07-13T07:06:00Z",
+        },
+      });
+      expect(html.match(/Health observed<\/th>/g)).toHaveLength(2);
+      expect(html.match(/Probe: <span[^>]*>1h ago<\/span>/g)).toHaveLength(2);
+      expect(html.match(/>6m ago<\/span><\/td>/g)).toHaveLength(2);
+    } finally {
+      clock.mockRestore();
+    }
+  });
+
+  it("shows an absent scale-down probe independently of published health", () => {
+    const html = renderScaleDown({
+      ...gkeChild,
+      scaleDown: { status: "InProgress" },
+    });
+    expect(html.match(/Probe: <span[^>]*>not probed<\/span>/g)).toHaveLength(2);
+  });
+
+  it.each([
+    "InProgress",
+    "CandidatesPresent",
+    "NoCandidates",
+    "NewControllerStatus",
+  ])(
+    "makes the %s removal caveat keyboard reachable without a count glyph",
+    (status) => {
+      const html = renderScaleDown({
+        ...gkeChild,
+        scaleDown: { status },
+      });
+      expect(
+        html.match(
+          /tabindex="0" role="note" aria-label="[^"]*PodDisruptionBudgets[^"]*"/g,
+        ),
+      ).toHaveLength(2);
+    },
+  );
+
+  it("never invents a zero count from NoCandidates or missing observations", () => {
+    const html = renderScaleDown({
+      ...gkeChild,
+      scaleDown: { status: "NoCandidates" },
+    });
+    expect(html).toMatch(/Candidates:(?:<!-- -->|\s)*not published/);
+    expect(html).toContain("Candidate count not published by the autoscaler.");
+    expect(html).not.toContain("Probe time not published");
+    expect(html).not.toContain("Status since");
+    expect(html).not.toMatch(/Candidates:(?:<!-- -->|\s)*0/);
+    const older = renderScaleDown(gkeChild);
+    expect(older).not.toContain("Scale-down</th>");
+    expect(older).not.toContain("Not published");
+    expect(older).not.toContain("PodDisruptionBudgets");
+  });
+
+  it("keeps a status-only CandidatesPresent count unknown", () => {
+    const html = renderScaleDown({
+      ...gkeChild,
+      scaleDown: { status: "CandidatesPresent" },
+    });
+    expect(html).toContain("Scale-down candidates present");
+    expect(html).toContain("Candidates: not published");
+    expect(html).not.toContain("0 scale-down candidates");
+  });
+
+  it.each(["joined", "orphan"])(
+    "shows both tables when only a %s child has scale-down data",
+    (source) => {
+      const withScaleDown = {
+        ...gkeChild,
+        scaleDown: { status: "NoCandidates", candidates: 0 },
+      };
+      const html = renderCapacity("/capacity", (client) =>
+        client.setQueryData(["capacity", "overview"], {
+          ...comprehensiveOverview(),
+          groups: [
+            {
+              ...gkeGroup,
+              children: [source === "joined" ? withScaleDown : gkeChild],
+            },
+          ],
+          orphanAutoscalerGroups: [
+            source === "orphan" ? withScaleDown : gkeChild,
+          ],
+        }),
+      );
+      expect(html.match(/Scale-down<\/th>/g)).toHaveLength(2);
+      expect(html).toContain("Not published");
+      expect(html).toContain("No scale-down candidates");
+    },
+  );
+
+  it("opens the removal caveat on status focus and dismisses it on blur", async () => {
+    const client = new QueryClient({
+      defaultOptions: { queries: { retry: false, staleTime: Infinity } },
+    });
+    client.setQueryData(["capacity", "overview"], {
+      ...comprehensiveOverview(),
+      groups: [],
+      orphanAutoscalerGroups: [
+        {
+          ...gkeChild,
+          scaleDown: { status: "InProgress", candidates: 2 },
+        },
+      ],
+    });
+    const container = document.createElement("div");
+    document.body.append(container);
+    const root = createRoot(container);
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    vi.useFakeTimers();
+    try {
+      await act(async () => {
+        root.render(
+          <MemoryRouter initialEntries={["/capacity"]}>
+            <QueryClientProvider client={client}>
+              <CapacityView onOpenResource={() => {}} />
+            </QueryClientProvider>
+          </MemoryRouter>,
+        );
+      });
+      const trigger = container.querySelector<HTMLElement>(
+        '[role="note"][aria-label^="Scale-down in progress."]',
+      );
+      expect(trigger).not.toBeNull();
+      expect(trigger!.textContent).toBe("Scale-down in progress");
+      expect(trigger!.querySelector('[tabindex="0"]')).toBeNull();
+      await act(async () => {
+        trigger!.focus();
+        await vi.advanceTimersByTimeAsync(400);
+      });
+      expect(document.activeElement).toBe(trigger);
+      expect(document.querySelector('[role="tooltip"]')?.textContent).toContain(
+        "PodDisruptionBudgets",
+      );
+      await act(async () => {
+        trigger!.blur();
+      });
+      expect(document.querySelector('[role="tooltip"]')).toBeNull();
+    } finally {
+      await act(async () => {
+        root.unmount();
+      });
+      client.clear();
+      container.remove();
+      vi.useRealTimers();
+      vi.unstubAllGlobals();
+    }
+  });
+
+  it("renders the server candidate fact on the collapsed pool", () => {
+    const html = renderCapacity("/capacity", (client) =>
+      client.setQueryData(["capacity", "overview"], {
+        ...comprehensiveOverview(),
+        groups: [
+          {
+            ...gkeGroup,
+            scaling: [
+              {
+                code: "scale_down_candidates",
+                summary: "3 scale-down candidates",
+              },
+            ],
+          },
+        ],
+      }),
+    );
+    expect(html).toContain("3 scale-down candidates");
+    expect(html).toMatch(/tabindex="0" role="note" aria-label="3 scale-down candidates\. [^"]*PodDisruptionBudgets/);
+    expect(html).toContain(candidateExplanation.replaceAll("'", "&#x27;"));
+    expect(html).not.toContain("scale-down delay");
+    expect(html).not.toContain("Radar can&#x27;t see those blockers");
+    expect(html).toContain('aria-expanded="false"');
+  });
+
+  it.each([
+    ["CandidatesPresent", "2 scale-down candidates"],
+    ["InProgress", "Scale-down in progress"],
+    ["NewControllerStatus", "NewControllerStatus"],
+    ["constructor", "constructor"],
+  ])("renders %s without promising a removal time", (status, label) => {
+    const html = renderScaleDown({
+      ...gkeChild,
+      scaleDown: { status, candidates: 2 },
+    });
+    expect(html).toContain(label);
+    expect(html).toContain("2 scale-down candidates");
+    expect(html).not.toContain("unneeded");
+    expect(html).not.toContain("Candidates:");
+    expect(html).not.toContain("Status since");
+  });
+
+  it("names a single published candidate the same way the pool row does", () => {
+    const html = renderScaleDown({
+      ...gkeChild,
+      scaleDown: { status: "CandidatesPresent", candidates: 1 },
+    });
+    expect(html).toMatch(
+      /role="note" aria-label="1 scale-down candidate\. Scale-down candidates are observations/,
+    );
+    expect(html).toContain(candidateExplanation.replaceAll("'", "&#x27;"));
+    expect(html).not.toContain("1 scale-down candidates");
+  });
+});
+
 describe("CapacityView pool detail", () => {
   it("renders the capacity ledger with headers and a certainty legend", () => {
     const html = renderCapacity("/capacity/pools/default", (client) =>

package/src/components/capacity/ClusterSchedulingCard.tsx

@@ -9,16 +9,8 @@ import {
   parseCPUToNanocores,
   parseQuantityToNumber,
 } from "@skyhook-io/k8s-ui/utils/format";
-import {
-  CertaintyGlyph,
-  LinkButton,
-  SectionCard,
-  certaintyGlyph,
-  certaintyValueLabel,
-  formatQuantity,
-  quantityResourceRank,
-  resourceLabel,
-} from "./shared";
+import { LinkButton, SectionCard, formatQuantity, quantityResourceRank, resourceLabel } from "./shared";
+import { CertaintyGlyph, certaintyGlyph, certaintyValueLabel } from "@skyhook-io/k8s-ui";
 
 // Karpenter scheduling capacity — the fleet-level "how full is Karpenter, and
 // how much is knocking at the door" bar. Karpenter-pooled nodes only: on mixed

package/src/components/capacity/certaintyGlyph.test.tsx

@@ -4,15 +4,8 @@ import type {
   CapacityActivityState,
   CapacityQuantityObservation,
 } from "@skyhook-io/k8s-ui";
-import {
-  DeniedCapacityState,
-  ActivityStateBadge,
-  CertaintyGlyph,
-  InventoryQuantityCell,
-  QuantityInline,
-  certaintyGlyph,
-  managerStatusRank,
-} from "./shared";
+import { DeniedCapacityState, ActivityStateBadge, InventoryQuantityCell, QuantityInline, managerStatusRank } from "./shared";
+import { CertaintyGlyph, certaintyGlyph } from "@skyhook-io/k8s-ui";
 
 function observation(
   certainty: CapacityQuantityObservation["certainty"],

package/src/components/capacity/routes.ts

@@ -0,0 +1,42 @@
+export type CapacityTopTab = "overview" | "demand" | "activity";
+export type PoolSection = "summary" | "workloads" | "members" | "configuration";
+
+export interface CapacityRoute {
+  topTab: CapacityTopTab;
+  poolName?: string;
+  poolSection: PoolSection;
+}
+
+export function parseCapacityRoute(pathname: string): CapacityRoute {
+  const segments = pathname.replace(/^\/+|\/+$/g, "").split("/");
+  if (segments[0] !== "capacity")
+    return { topTab: "overview", poolSection: "summary" };
+  if (segments[1] === "pools" && segments[2]) {
+    const section = segments[3];
+    return {
+      topTab: "overview",
+      poolName: decodePathSegment(segments[2]),
+      poolSection:
+        section === "workloads" ||
+        section === "members" ||
+        section === "configuration"
+          ? section
+          : "summary",
+    };
+  }
+  if (segments[1] === "demand" || segments[1] === "activity")
+    return { topTab: segments[1], poolSection: "summary" };
+  return { topTab: "overview", poolSection: "summary" };
+}
+
+function decodePathSegment(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export function capacityPoolPath(name: string): string {
+  return `/capacity/pools/${encodeURIComponent(name)}`;
+}

package/src/components/capacity/shared.tsx

@@ -2,7 +2,6 @@ import {
   useCallback,
   useEffect,
   useState,
-  type ComponentType,
   type ReactNode,
 } from "react";
 import {
@@ -25,6 +24,8 @@ import {
   ResourceBar,
   Tooltip,
   WithTooltip,
+  certaintyValueLabel,
+  CertaintyGlyph,
   type CapacityActivityEpisode,
   type CapacityCertainty,
   type CapacityClaimStage,
@@ -61,22 +62,19 @@ import {
 } from "../../api/client";
 import type { SelectedResource } from "../../types";
 import { refToSelectedResource } from "../../utils/navigation";
+import { Notice, ScreenEmptyState } from "../workspace/layout";
 
 // ============================================================================
 // Route model + navigation
 // ============================================================================
 
-export type CapacityTopTab = "overview" | "demand" | "activity";
-export type PoolSection = "summary" | "workloads" | "members" | "configuration";
+import type { PoolSection } from './routes'
+export { capacityPoolPath, parseCapacityRoute } from './routes'
+export type { CapacityRoute, CapacityTopTab, PoolSection } from './routes'
+
 export type CapacityConnectionState =
   "connected" | "disconnected" | "connecting";
 
-export interface CapacityRoute {
-  topTab: CapacityTopTab;
-  poolName?: string;
-  poolSection: PoolSection;
-}
-
 export const POOL_SECTIONS: { id: PoolSection; label: string }[] = [
   { id: "summary", label: "Summary" },
   { id: "workloads", label: "Workloads" },
@@ -84,40 +82,6 @@ export const POOL_SECTIONS: { id: PoolSection; label: string }[] = [
   { id: "configuration", label: "Configuration" },
 ];
 
-export function parseCapacityRoute(pathname: string): CapacityRoute {
-  const segments = pathname.replace(/^\/+|\/+$/g, "").split("/");
-  if (segments[0] !== "capacity")
-    return { topTab: "overview", poolSection: "summary" };
-  if (segments[1] === "pools" && segments[2]) {
-    const section = segments[3];
-    return {
-      topTab: "overview",
-      poolName: decodePathSegment(segments[2]),
-      poolSection:
-        section === "workloads" ||
-        section === "members" ||
-        section === "configuration"
-          ? section
-          : "summary",
-    };
-  }
-  if (segments[1] === "demand" || segments[1] === "activity")
-    return { topTab: segments[1], poolSection: "summary" };
-  return { topTab: "overview", poolSection: "summary" };
-}
-
-function decodePathSegment(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-export function capacityPoolPath(name: string): string {
-  return `/capacity/pools/${encodeURIComponent(name)}`;
-}
-
 export function identityToSelectedResource(
   identity: CapacityResourceIdentity,
 ): SelectedResource {
@@ -266,20 +230,6 @@ function missingUsageMessage(coverage?: CapacitySourceCoverage): string {
 // = exact · ≥ lower bound · ≤ upper bound · ? unknown
 // ============================================================================
 
-export function certaintyGlyph(certainty: CapacityCertainty): string {
-  if (certainty === "exact") return "=";
-  if (certainty === "lower_bound") return "≥";
-  if (certainty === "upper_bound") return "≤";
-  return "?";
-}
-
-export function certaintyValueLabel(certainty: CapacityCertainty): string {
-  if (certainty === "exact") return "Exact";
-  if (certainty === "lower_bound") return "Lower bound";
-  if (certainty === "upper_bound") return "Upper bound";
-  return "Unknown certainty";
-}
-
 export function observationTitle(
   observation: CapacityQuantityObservation,
   definition?: string,
@@ -295,28 +245,6 @@ export function observationTitle(
   return parts.join(" ");
 }
 
-/** Small bordered mono glyph chip; hover reveals certainty/source/asOf. */
-export function CertaintyGlyph({
-  certainty,
-  title,
-}: {
-  certainty: CapacityCertainty;
-  title?: string;
-}) {
-  return (
-    <WithTooltip tip={title ?? certaintyValueLabel(certainty)}>
-      <span
-        tabIndex={0}
-        role="note"
-        aria-label={title ?? certaintyValueLabel(certainty)}
-        className="cursor-help rounded border border-theme-border-light px-1 font-mono text-[10px] leading-tight text-theme-text-tertiary focus-visible:outline focus-visible:outline-2 focus-visible:outline-skyhook-500"
-      >
-        {certaintyGlyph(certainty)}
-      </span>
-    </WithTooltip>
-  );
-}
-
 // ============================================================================
 // Quantity / resource formatting
 // ============================================================================
@@ -1241,15 +1169,6 @@ export function TokenGroup({
   );
 }
 
-export function Notice({ children }: { children: ReactNode }) {
-  return (
-    <div className="flex items-start gap-2 rounded-lg border border-theme-border bg-theme-surface px-3 py-2 text-sm text-theme-text-secondary">
-      <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0 text-theme-text-tertiary" />
-      <div>{children}</div>
-    </div>
-  );
-}
-
 export function RefreshError({ message }: { message: string }) {
   return (
     <Notice>
@@ -1327,31 +1246,6 @@ export function InlineEmpty({
   );
 }
 
-export function EmptyState({
-  icon: Icon,
-  title,
-  detail,
-  action,
-}: {
-  icon: ComponentType<{ className?: string }>;
-  title: string;
-  detail: ReactNode;
-  action?: ReactNode;
-}) {
-  return (
-    <div className="flex min-h-0 flex-1 items-center justify-center bg-theme-base p-6">
-      <div className="max-w-md text-center">
-        <Icon className="mx-auto h-9 w-9 text-theme-text-tertiary/50" />
-        <h2 className="mt-3 text-lg font-medium text-theme-text-primary">
-          {title}
-        </h2>
-        <p className="mt-1 text-sm text-theme-text-secondary">{detail}</p>
-        {action}
-      </div>
-    </div>
-  );
-}
-
 export function ScrollableContent({ children }: { children: ReactNode }) {
   // Expanding/collapsing cards can toggle the scrollbar; a stable gutter
   // keeps the centered column from shifting sideways when that happens.
@@ -1460,7 +1354,7 @@ rules:
 export function DeniedCapacityState({ detail }: { detail: string }) {
   const [copied, setCopied] = useState(false);
   return (
-    <EmptyState
+    <ScreenEmptyState
       icon={Shield}
       title="Capacity access denied"
       detail={detail}
@@ -1519,7 +1413,7 @@ export function integrationBlock(
     const upgrade = getRadarUpgradeRequirement(error);
     if (upgrade)
       return (
-        <EmptyState
+        <ScreenEmptyState
           icon={Gauge}
           title={radarUpgradeHeadline("Capacity")}
           detail={radarUpgradeDetail(upgrade)}
@@ -1531,7 +1425,7 @@ export function integrationBlock(
         />
       );
     return (
-      <EmptyState
+      <ScreenEmptyState
         icon={AlertTriangle}
         title="Capacity unavailable"
         detail={errorMessage(error)}
@@ -1549,7 +1443,7 @@ export function integrationBlock(
     );
   if (response.state === "not_detected")
     return (
-      <EmptyState
+      <ScreenEmptyState
         icon={Gauge}
         title="Karpenter not detected"
         detail="Capacity appears automatically when this cluster exposes Karpenter NodePools."
@@ -1838,15 +1732,3 @@ export function PoolSelector({
     </div>
   );
 }
-
-// ============================================================================
-// Shared table cell classes (keeps every capacity table visually identical)
-// ============================================================================
-
-export const TABLE_WRAP = "overflow-x-auto";
-export const TABLE_HEAD =
-  "border-b border-theme-border bg-theme-base/60 text-[11px] uppercase tracking-wide text-theme-text-tertiary";
-export const TH = "px-3 py-2.5 text-left font-medium whitespace-nowrap";
-export const TD = "px-3 py-2.5 align-top text-sm text-theme-text-primary";
-export const TBODY = "table-divide-subtle";
-export const ROW_HOVER = "transition-colors hover:bg-theme-hover/50";

package/src/components/capacity/workspaceRoute.ts

@@ -0,0 +1,18 @@
+import type { WorkspaceRoute } from '../../integrations/workspaceRoute'
+import { parseCapacityRoute } from './routes'
+
+export const capacityWorkspaceRoute: WorkspaceRoute = {
+  id: 'capacity',
+  path: '/capacity',
+  label: 'Capacity',
+  navView: 'capacity',
+  namespaceScope: 'cluster',
+  namespaceFilterTooltip: 'Capacity is reported across the cluster — the namespace filter doesn’t apply here.',
+  pageTitle(pathname) {
+    const route = parseCapacityRoute(pathname)
+    if (route.poolName) return route.poolName
+    if (route.topTab === 'demand') return 'Capacity Demand'
+    if (route.topTab === 'activity') return 'Capacity Activity'
+    return 'Capacity'
+  },
+}