@checkstack/healthcheck-backend 1.18.0 → 1.19.0

package/src/status-page/rollup.test.ts

@@ -3,6 +3,7 @@ import {
   mapHealthStatus,
   rollupStatus,
   overallBannerStatus,
+  rollupSelectedEnvironments,
   statusBannerTitle,
 } from "./rollup";
 
@@ -45,6 +46,45 @@ describe("overallBannerStatus", () => {
   });
 });
 
+describe("rollupSelectedEnvironments", () => {
+  const environments = {
+    prod: { status: "healthy" },
+    staging: { status: "unhealthy" },
+    dev: { status: "degraded" },
+  };
+  test("considers only the selected environments (worst-wins)", () => {
+    expect(
+      rollupSelectedEnvironments({
+        environments,
+        selectedEnvironmentIds: ["prod"],
+      }),
+    ).toBe("operational");
+    expect(
+      rollupSelectedEnvironments({
+        environments,
+        selectedEnvironmentIds: ["prod", "staging"],
+      }),
+    ).toBe("major_outage");
+    expect(
+      rollupSelectedEnvironments({
+        environments,
+        selectedEnvironmentIds: ["prod", "dev"],
+      }),
+    ).toBe("degraded");
+  });
+  test("no slice in any selected env -> unknown", () => {
+    expect(
+      rollupSelectedEnvironments({
+        environments,
+        selectedEnvironmentIds: ["nonexistent"],
+      }),
+    ).toBe("unknown");
+    expect(
+      rollupSelectedEnvironments({ environments, selectedEnvironmentIds: [] }),
+    ).toBe("unknown");
+  });
+});
+
 describe("statusBannerTitle", () => {
   test("renders a human title", () => {
     expect(statusBannerTitle("operational")).toBe("All systems operational");

package/src/status-page/rollup.ts

@@ -58,6 +58,33 @@ export function overallBannerStatus(statuses: PublicStatus[]): PublicStatus {
   return rollupStatus(known);
 }
 
+/**
+ * Roll up a system's PER-ENVIRONMENT health-check statuses into a single public
+ * status for a status page scoped to specific environments. ONLY the slices for
+ * the selected environments are considered (worst-status-wins via the public
+ * precedence); a system with no slice in any selected environment resolves to
+ * `unknown`. Used by the health widgets when a page publishes an explicit
+ * environment set, so a system in both prod and staging shows only its
+ * selected-environment health rather than the cross-environment rollup.
+ *
+ * This considers CHECK statuses only. Incident-forced overrides are whole-system
+ * (not environment-scoped), so the caller folds the override IN via worst-wins on
+ * top of this result (see `healthPublicStatuses`) - keeping this helper a pure
+ * per-environment checks rollup.
+ */
+export function rollupSelectedEnvironments(args: {
+  environments: Record<string, { status: string }>;
+  selectedEnvironmentIds: string[];
+}): PublicStatus {
+  const { environments, selectedEnvironmentIds } = args;
+  const statuses: PublicStatus[] = [];
+  for (const envId of selectedEnvironmentIds) {
+    const slice = environments[envId];
+    if (slice) statuses.push(mapHealthStatus(slice.status));
+  }
+  return rollupStatus(statuses);
+}
+
 export function statusBannerTitle(status: PublicStatus): string {
   switch (status) {
     case "operational": {

package/src/status-page/widgets.test.ts

@@ -0,0 +1,303 @@
+import { describe, test, expect } from "bun:test";
+import type { RpcClient } from "@checkstack/backend-api";
+import type {
+  WidgetResolveContext,
+  WidgetTypeDefinition,
+  StatusWidgetTypeExtensionPoint,
+} from "@checkstack/status-page-backend";
+import { registerHealthcheckStatusWidgets } from "./widgets";
+
+/**
+ * Widget-level regression coverage for status-page environment filtering (the
+ * gap that let the standalone uptime widget slip through). Exercises the four
+ * health widgets directly against a mocked trusted rpcClient, asserting that a
+ * published-environment set:
+ *  - omits systems outside the selected environments from banner / systemHealth
+ *    / groupStatus AND blanks the single-system uptime widget, and
+ *  - folds the WHOLE-SYSTEM incident override into the env-scoped health rollup
+ *    (a prod system whose prod checks are green but which is under an active
+ *    incident-forced outage still reads as an outage on a prod-scoped page).
+ */
+
+/** Per-system per-environment CHECKS status, as getBulkSystemHealthMatrix returns. */
+type MatrixEnvStatus = "healthy" | "degraded" | "unhealthy";
+
+interface MockData {
+  /** environmentId -> member system ids (catalog env->systems mapping). */
+  envSystems: Record<string, string[]>;
+  /** systemId -> display name. */
+  systemNames: Record<string, string>;
+  /** systemId -> per-environment CHECKS status. */
+  matrix: Record<string, Record<string, MatrixEnvStatus>>;
+  /** systemId -> whole-system incident override status (folded, worst-wins). */
+  overrides?: Record<string, MatrixEnvStatus>;
+  /** systemId -> total uptime percent (for the uptime widget). */
+  uptimePct?: Record<string, number>;
+  /** catalog groupId -> member system ids. */
+  groups?: Record<string, string[]>;
+}
+
+function widgetsById(): Map<string, WidgetTypeDefinition> {
+  const map = new Map<string, WidgetTypeDefinition>();
+  const ext: StatusWidgetTypeExtensionPoint = {
+    registerWidgetType: (def) => map.set(def.id, def),
+  };
+  registerHealthcheckStatusWidgets(ext);
+  return map;
+}
+
+function makeCtx(args: {
+  data: MockData;
+  publishedEnvironmentIds?: string[];
+}): WidgetResolveContext {
+  const { data, publishedEnvironmentIds } = args;
+  const memo = new Map<string, Promise<unknown>>();
+  const api = {
+    // catalog
+    resolveEnvironments: async ({
+      environmentIds,
+    }: {
+      environmentIds: string[];
+    }) =>
+      environmentIds.map((id) => ({
+        id,
+        name: id,
+        description: null,
+        systemIds: data.envSystems[id] ?? [],
+        metadata: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      })),
+    getSystems: async () => ({
+      systems: Object.entries(data.systemNames).map(([id, name]) => ({
+        id,
+        name,
+      })),
+    }),
+    getGroups: async () =>
+      Object.entries(data.groups ?? {}).map(([id, systemIds]) => ({
+        id,
+        name: id,
+        systemIds,
+      })),
+    // maintenance
+    getBulkMaintenancesForSystems: async () => ({ maintenances: {} }),
+    // healthcheck
+    getBulkSystemHealthMatrix: async ({ systemIds }: { systemIds: string[] }) => {
+      const statuses: Record<
+        string,
+        {
+          status: MatrixEnvStatus;
+          checkStatuses: never[];
+          environments: Record<
+            string,
+            { status: MatrixEnvStatus; checkStatuses: never[] }
+          >;
+        }
+      > = {};
+      for (const id of systemIds) {
+        const envs = data.matrix[id];
+        if (!envs) continue;
+        statuses[id] = {
+          status: "healthy",
+          checkStatuses: [],
+          environments: Object.fromEntries(
+            Object.entries(envs).map(([env, status]) => [
+              env,
+              { status, checkStatuses: [] },
+            ]),
+          ),
+        };
+      }
+      return { statuses };
+    },
+    getBulkSystemHealthStatus: async ({ systemIds }: { systemIds: string[] }) => {
+      const statuses: Record<
+        string,
+        {
+          status: MatrixEnvStatus;
+          evaluatedAt: Date;
+          checkStatuses: never[];
+          override?: { status: MatrixEnvStatus; source: string; reason: string };
+        }
+      > = {};
+      for (const id of systemIds) {
+        const override = data.overrides?.[id];
+        statuses[id] = {
+          status: "healthy",
+          evaluatedAt: new Date(),
+          checkStatuses: [],
+          ...(override
+            ? { override: { status: override, source: "incident", reason: "x" } }
+            : {}),
+        };
+      }
+      return { statuses };
+    },
+    getRunStats: async ({ systemId }: { systemId: string }) => {
+      const pct = data.uptimePct?.[systemId] ?? 100;
+      return {
+        window: { start: "2026-07-01T00:00:00Z", end: "2026-07-02T00:00:00Z" },
+        bucketIntervalSeconds: 86_400,
+        total: {
+          runCount: 10,
+          healthy: 10,
+          degraded: 0,
+          unhealthy: 0,
+          uptimePct: pct,
+        },
+        buckets: [
+          {
+            start: "2026-07-01T00:00:00Z",
+            end: "2026-07-02T00:00:00Z",
+            runCount: 10,
+            healthy: 10,
+            degraded: 0,
+            unhealthy: 0,
+            uptimePct: pct,
+          },
+        ],
+      };
+    },
+  };
+  return {
+    rpcClient: { forPlugin: () => api } as unknown as RpcClient,
+    cache: <T,>(key: string, loader: () => Promise<T>): Promise<T> => {
+      const existing = memo.get(key);
+      if (existing) return existing as Promise<T>;
+      const created = loader();
+      memo.set(key, created);
+      return created;
+    },
+    publishedEnvironmentIds,
+  };
+}
+
+// prod-sys: prod only (checks healthy, but under an active incident override).
+// stage-sys: staging only (checks unhealthy).
+// both-sys: prod + staging (prod healthy, staging unhealthy).
+const DATA: MockData = {
+  envSystems: {
+    prod: ["prod-sys", "both-sys"],
+    stage: ["stage-sys", "both-sys"],
+  },
+  systemNames: {
+    "prod-sys": "Prod System",
+    "stage-sys": "Stage System",
+    "both-sys": "Both System",
+  },
+  matrix: {
+    "prod-sys": { prod: "healthy" },
+    "stage-sys": { stage: "unhealthy" },
+    "both-sys": { prod: "healthy", stage: "unhealthy" },
+  },
+  overrides: { "prod-sys": "unhealthy" }, // whole-system incident-forced outage
+  uptimePct: { "prod-sys": 99, "stage-sys": 50, "both-sys": 88 },
+  groups: { g1: ["prod-sys", "stage-sys"] },
+};
+
+describe("health widgets — environment filtering (E3 regression)", () => {
+  const publishedEnvironmentIds = ["prod"];
+
+  test("systemHealth omits staging-only systems and folds the whole-system override", async () => {
+    const widget = widgetsById().get("systemHealth")!;
+    const ctx = makeCtx({ data: DATA, publishedEnvironmentIds });
+    const result = (await widget.resolvePublic({
+      config: {
+        items: [
+          { systemId: "prod-sys" },
+          { systemId: "stage-sys" },
+          { systemId: "both-sys" },
+        ],
+      },
+      ctx,
+    })) as { systems: Array<{ label: string; status: string }> };
+    // stage-sys is dropped; prod-sys shows the incident override (major_outage)
+    // even though its prod checks are healthy; both-sys shows its prod checks.
+    expect(result.systems).toEqual([
+      { label: "Prod System", status: "major_outage" },
+      { label: "Both System", status: "operational" },
+    ]);
+  });
+
+  test("banner rolls up only env-visible systems, override included", async () => {
+    const widget = widgetsById().get("banner")!;
+    const ctx = makeCtx({ data: DATA, publishedEnvironmentIds });
+    const result = (await widget.resolvePublic({
+      config: { systemIds: ["prod-sys", "stage-sys", "both-sys"] },
+      ctx,
+    })) as { status: string };
+    // Visible = {prod-sys (major via override), both-sys (operational)} ->
+    // some-but-not-all down = partial_outage. stage-sys never counted.
+    expect(result.status).toBe("partial_outage");
+  });
+
+  test("groupStatus drops group members outside the published environments", async () => {
+    const widget = widgetsById().get("groupStatus")!;
+    const ctx = makeCtx({ data: DATA, publishedEnvironmentIds });
+    const result = (await widget.resolvePublic({
+      config: { groupId: "g1" },
+      ctx,
+    })) as { systems: Array<{ label: string; status: string }>; status: string };
+    // g1 = [prod-sys, stage-sys]; only prod-sys is in prod. Its override lifts
+    // it to major_outage; stage-sys is omitted entirely.
+    expect(result.systems).toEqual([
+      { label: "Prod System", status: "major_outage" },
+    ]);
+    expect(result.status).toBe("major_outage");
+  });
+
+  test("uptime widget is blanked for a system outside the published environments", async () => {
+    const widget = widgetsById().get("uptime")!;
+    const ctx = makeCtx({ data: DATA, publishedEnvironmentIds });
+    const result = (await widget.resolvePublic({
+      config: { systemId: "stage-sys", days: 30 },
+      ctx,
+    })) as { label: string; uptimePct: number; bars: unknown[] };
+    // Out of scope -> blank empty-state DTO (no bars, no misleading percent).
+    expect(result.bars).toEqual([]);
+    expect(result.uptimePct).toBe(0);
+  });
+
+  test("uptime widget renders normally for an in-scope system", async () => {
+    const widget = widgetsById().get("uptime")!;
+    const ctx = makeCtx({ data: DATA, publishedEnvironmentIds });
+    const result = (await widget.resolvePublic({
+      config: { systemId: "prod-sys", days: 30 },
+      ctx,
+    })) as { label: string; uptimePct: number; bars: unknown[] };
+    expect(result.label).toBe("Prod System");
+    expect(result.bars.length).toBe(1);
+    expect(result.uptimePct).toBe(99);
+  });
+});
+
+describe("health widgets — no environment filter (unchanged behavior)", () => {
+  test("systemHealth keeps every system and uses the folded cross-env status", async () => {
+    const widget = widgetsById().get("systemHealth")!;
+    const ctx = makeCtx({ data: DATA }); // no publishedEnvironmentIds
+    const result = (await widget.resolvePublic({
+      config: {
+        items: [{ systemId: "prod-sys" }, { systemId: "stage-sys" }],
+      },
+      ctx,
+    })) as { systems: Array<{ label: string; status: string }> };
+    // All-env path reads getBulkSystemHealthStatus.status (healthy in the mock)
+    // for both systems; no system is dropped.
+    expect(result.systems).toEqual([
+      { label: "Prod System", status: "operational" },
+      { label: "Stage System", status: "operational" },
+    ]);
+  });
+
+  test("uptime widget is never blanked when no environment filter is set", async () => {
+    const widget = widgetsById().get("uptime")!;
+    const ctx = makeCtx({ data: DATA });
+    const result = (await widget.resolvePublic({
+      config: { systemId: "stage-sys", days: 30 },
+      ctx,
+    })) as { bars: unknown[]; uptimePct: number };
+    expect(result.bars.length).toBe(1);
+    expect(result.uptimePct).toBe(50);
+  });
+});

package/src/status-page/widgets.ts

@@ -23,12 +23,51 @@ import {
   mapHealthStatus,
   rollupStatus,
   overallBannerStatus,
+  rollupSelectedEnvironments,
   statusBannerTitle,
 } from "./rollup";
 
 const SYSTEM_TYPE = "catalog.system";
 const GROUP_TYPE = "catalog.group";
 
+/**
+ * The catalog system ids visible under the page's published-environment scope,
+ * or null when the page publishes all environments (no filter). Resolved once
+ * per page resolve (cache-keyed by the env set) from the catalog's own
+ * env->systems mapping, so a system in NONE of the selected environments is
+ * omitted from every health widget.
+ */
+async function envVisibleSystems(
+  ctx: WidgetResolveContext,
+): Promise<Set<string> | null> {
+  const envIds = ctx.publishedEnvironmentIds;
+  if (!envIds || envIds.length === 0) return null;
+  const key = `catalog.systemsInEnv:${[...envIds].toSorted().join(",")}`;
+  const ids = await ctx.cache(key, async () => {
+    const envs = await ctx.rpcClient
+      .forPlugin(CatalogApi)
+      .resolveEnvironments({ environmentIds: envIds });
+    const set = new Set<string>();
+    for (const env of envs) for (const s of env.systemIds) set.add(s);
+    return [...set];
+  });
+  return new Set(ids);
+}
+
+/**
+ * Restrict a widget's configured system ids to those visible under the page's
+ * published-environment scope. Returns the ids unchanged when the page publishes
+ * all environments.
+ */
+async function scopeToEnv(
+  ctx: WidgetResolveContext,
+  ids: string[],
+): Promise<string[]> {
+  const visible = await envVisibleSystems(ctx);
+  if (!visible) return ids;
+  return ids.filter((id) => visible.has(id));
+}
+
 function uptimeToStatus(pct: number): PublicStatus {
   if (pct >= 99.5) return "operational";
   if (pct >= 95) return "degraded";
@@ -83,25 +122,69 @@ async function inMaintenance(
   return out;
 }
 
-async function healthStatuses(
+/**
+ * Per-system HEALTH-derived PUBLIC status (before the maintenance override).
+ *
+ * - Page publishes ALL environments: the cross-environment rollup via
+ *   `getBulkSystemHealthStatus`, which folds active incident overrides into the
+ *   status (so the public page shows the forced status).
+ * - Page publishes a SPECIFIC environment set: the per-environment matrix rolled
+ *   up over ONLY the selected environments (`rollupSelectedEnvironments`), then
+ *   the whole-system incident override folded IN via worst-wins. Incident
+ *   overrides are whole-system (not env-scoped), so they must apply regardless of
+ *   which environments the page publishes - otherwise a system whose checks are
+ *   green in the selected env but which is under an active incident-forced outage
+ *   would wrongly read healthy. The override status comes from the SAME source as
+ *   the all-env path (`getBulkSystemHealthStatus`, which folds it and surfaces it
+ *   on `override`), so both modes show the identical forced status.
+ *
+ * In BOTH modes only the derived status enum is read - never `override.reason`
+ * (the incident TITLE) or per-check detail - so no internal name reaches a
+ * public widget DTO.
+ */
+async function healthPublicStatuses(
   ctx: WidgetResolveContext,
   ids: string[],
-): Promise<Record<string, { status: string } | undefined>> {
-  if (ids.length === 0) return {};
+): Promise<Map<string, PublicStatus>> {
+  const out = new Map<string, PublicStatus>();
+  if (ids.length === 0) return out;
+  const envIds = ctx.publishedEnvironmentIds;
+  if (envIds && envIds.length > 0) {
+    const client = ctx.rpcClient.forPlugin(HealthCheckApi);
+    // Matrix = per-environment CHECKS status; bulk status carries the
+    // whole-system incident override (on `override`). Fetch both, roll up only
+    // the selected envs' checks, then fold the override in (worst-wins).
+    const [matrixRes, bulkRes] = await Promise.all([
+      client.getBulkSystemHealthMatrix({ systemIds: ids }),
+      client.getBulkSystemHealthStatus({ systemIds: ids }),
+    ]);
+    for (const id of ids) {
+      const matrix = matrixRes.statuses[id];
+      const envChecks: PublicStatus = matrix
+        ? rollupSelectedEnvironments({
+            environments: matrix.environments,
+            selectedEnvironmentIds: envIds,
+          })
+        : "unknown";
+      const overrideStatus = bulkRes.statuses[id]?.override?.status;
+      // rollupStatus is worst-wins over the public vocabulary, so the override
+      // lifts the status exactly as `applySystemHealthOverrides` does upstream.
+      out.set(
+        id,
+        overrideStatus
+          ? rollupStatus([envChecks, mapHealthStatus(overrideStatus)])
+          : envChecks,
+      );
+    }
+    return out;
+  }
   const { statuses } = await ctx.rpcClient
     .forPlugin(HealthCheckApi)
     .getBulkSystemHealthStatus({ systemIds: ids });
-  // Project to ONLY the derived status. `getBulkSystemHealthStatus` folds active
-  // incident overrides into `status` (so the public page shows the forced
-  // status), but the response also carries `override.reason` = the incident
-  // TITLE. Status pages are public and incidents may be hidden, so we drop
-  // everything but the status here - the incident name must never reach a public
-  // widget DTO.
-  const projected: Record<string, { status: string } | undefined> = {};
   for (const [systemId, value] of Object.entries(statuses)) {
-    projected[systemId] = value ? { status: value.status } : undefined;
+    if (value) out.set(systemId, mapHealthStatus(value.status));
   }
-  return projected;
+  return out;
 }
 
 function publicStatus({
@@ -110,12 +193,11 @@ function publicStatus({
   maint,
 }: {
   systemId: string;
-  health: Record<string, { status: string } | undefined>;
+  health: Map<string, PublicStatus>;
   maint: Set<string>;
 }): PublicStatus {
   if (maint.has(systemId)) return "maintenance";
-  const internal = health[systemId]?.status;
-  return internal ? mapHealthStatus(internal) : "unknown";
+  return health.get(systemId) ?? "unknown";
 }
 
 /** assertBindingsReadable for system-bound widgets. */
@@ -148,10 +230,12 @@ const banner: WidgetTypeDefinition = {
   })),
   async resolvePublic({ config, ctx }) {
     const c = BannerConfigSchema.parse(config);
-    const health = await healthStatuses(ctx, c.systemIds);
-    const maint = await inMaintenance(ctx, c.systemIds);
+    // Omit systems outside the page's published environments before rolling up.
+    const ids = await scopeToEnv(ctx, c.systemIds);
+    const health = await healthPublicStatuses(ctx, ids);
+    const maint = await inMaintenance(ctx, ids);
     const status = overallBannerStatus(
-      c.systemIds.map((systemId) => publicStatus({ systemId, health, maint })),
+      ids.map((systemId) => publicStatus({ systemId, health, maint })),
     );
     return BannerDtoSchema.parse({
       status,
@@ -178,12 +262,17 @@ const systemHealth: WidgetTypeDefinition = {
   })),
   async resolvePublic({ config, ctx }) {
     const c = SystemHealthConfigSchema.parse(config);
-    const ids = c.items.map((i) => i.systemId);
-    const health = await healthStatuses(ctx, ids);
+    // Drop rows for systems outside the page's published environments.
+    const visible = await envVisibleSystems(ctx);
+    const items = visible
+      ? c.items.filter((i) => visible.has(i.systemId))
+      : c.items;
+    const ids = items.map((i) => i.systemId);
+    const health = await healthPublicStatuses(ctx, ids);
     const maint = await inMaintenance(ctx, ids);
     const names = await labelsFor(ctx, ids);
     const uptime = c.showUptime ? await uptimeMap(ctx, ids) : undefined;
-    const systems = c.items.map((item) => {
+    const systems = items.map((item) => {
       const pct = uptime?.get(item.systemId);
       return {
         label: item.label ?? names.get(item.systemId) ?? item.systemId,
@@ -199,22 +288,30 @@ async function uptimeMap(
   ctx: WidgetResolveContext,
   ids: string[],
 ): Promise<Map<string, number>> {
+  const out = new Map<string, number>();
+  if (ids.length === 0) return out;
   const end = new Date();
   const start = new Date(end.getTime() - 30 * 86_400_000);
-  const out = new Map<string, number>();
-  const results = await Promise.allSettled(
-    ids.map(async (systemId) => {
-      const stats = await ctx.rpcClient
-        .forPlugin(HealthCheckApi)
-        .getRunStats({ systemId, startDate: start, endDate: end, maxBuckets: 1 });
-      // No runs in the window => no uptime to report (don't surface a
-      // misleading 0.00% for a system with no history).
-      if (stats.total.runCount === 0) return null;
-      return [systemId, stats.total.uptimePct] as const;
-    }),
-  );
-  for (const r of results) {
-    if (r.status === "fulfilled" && r.value) out.set(r.value[0], r.value[1]);
+  // ONE bulk call for every system's uptime, instead of an N+1 fan-out of
+  // per-system `getRunStats` (each holding a pooled connection). Systems with
+  // no runs are omitted from `stats`, so they never enter the map - preserving
+  // the previous "no runs => no misleading 0.00%" behavior exactly. When the
+  // page publishes a specific environment set, uptime counts only runs in those
+  // environments (env-less runs excluded).
+  const { stats } = await ctx.rpcClient
+    .forPlugin(HealthCheckApi)
+    .getBulkRunStats({
+      systemIds: ids,
+      startDate: start,
+      endDate: end,
+      ...(ctx.publishedEnvironmentIds
+        ? { environmentIds: ctx.publishedEnvironmentIds }
+        : {}),
+      maxBuckets: 1,
+    });
+  for (const systemId of ids) {
+    const s = stats[systemId];
+    if (s && s.total.runCount > 0) out.set(systemId, s.total.uptimePct);
   }
   return out;
 }
@@ -237,8 +334,9 @@ const groupStatus: WidgetTypeDefinition = {
     const c = GroupStatusConfigSchema.parse(config);
     const groups = await allGroups(ctx);
     const group = groups.find((g) => g.id === c.groupId);
-    const ids = group?.systemIds ?? [];
-    const health = await healthStatuses(ctx, ids);
+    // Omit group members outside the page's published environments.
+    const ids = await scopeToEnv(ctx, group?.systemIds ?? []);
+    const health = await healthPublicStatuses(ctx, ids);
     const maint = await inMaintenance(ctx, ids);
     const names = await labelsFor(ctx, ids);
     const systems = ids.map((systemId) => ({
@@ -249,6 +347,7 @@ const groupStatus: WidgetTypeDefinition = {
       label: c.label ?? group?.name ?? "Group",
       status: rollupStatus(systems.map((s) => s.status)),
       systems,
+      collapseWhenHealthy: c.collapseWhenHealthy,
     });
   },
 };
@@ -269,17 +368,34 @@ const uptime: WidgetTypeDefinition = {
   })),
   async resolvePublic({ config, ctx }) {
     const c = UptimeConfigSchema.parse(config);
+    const names = await labelsFor(ctx, [c.systemId]);
+    const label = c.label ?? names.get(c.systemId) ?? c.systemId;
+    // Omit this system's uptime when it is outside the page's published
+    // environments: emit the blank empty-state DTO (empty bars) the sibling
+    // health widgets use for out-of-scope systems, so the single-system uptime
+    // widget never shows misleading or stale-environment uptime. Gated on the
+    // CURRENT catalog env membership (`envVisibleSystems`), NOT on "getRunStats
+    // returned nothing" - so a system removed from the published env but still
+    // carrying old env-tagged runs is correctly blanked. No env filter (visible
+    // is null) leaves behavior unchanged.
+    const visible = await envVisibleSystems(ctx);
+    if (visible && !visible.has(c.systemId)) {
+      return UptimeDtoSchema.parse({ label, uptimePct: 0, bars: [] });
+    }
     const end = new Date();
     const start = new Date(end.getTime() - c.days * 86_400_000);
     const stats = await ctx.rpcClient.forPlugin(HealthCheckApi).getRunStats({
       systemId: c.systemId,
       startDate: start,
       endDate: end,
+      // Scope uptime to the page's published environments when set.
+      ...(ctx.publishedEnvironmentIds
+        ? { environmentIds: ctx.publishedEnvironmentIds }
+        : {}),
       maxBuckets: c.days,
     });
-    const names = await labelsFor(ctx, [c.systemId]);
     return UptimeDtoSchema.parse({
-      label: c.label ?? names.get(c.systemId) ?? c.systemId,
+      label,
       uptimePct: stats.total.uptimePct,
       bars: stats.buckets.map((b) => ({
         date: b.start,