@cosmicdrift/kumiko-samples 0.338.0

package/packages/bundled-features/src/cap-overview/feature.ts

@@ -0,0 +1,87 @@
+// cap-overview — read-only tier/cap-usage visibility per tenant.
+//
+// **What this feature does:**
+//   1. tenant-caps:list query + tenant-cap-list screen — SystemAdmin-only
+//      platform-wide table of every tenant's tier, billing status, and
+//      usage against a configurable set of caps.
+//   2. caps:usage query + my-caps / platform-tenant-caps dashboards —
+//      per-tenant usage cards. Tenant admins see their own
+//      tenant (`usageVisibleTo` widens it); SystemAdmin can additionally view any tenant via `tenantId`.
+//
+// **What this feature does NOT do:**
+//   - No writes. Reads tier-engine's read_tier_assignments, billing-
+//     foundation's read_subscriptions, tenant's read_tenants, plus
+//     app-owned usage tables via the caller-supplied `CapSpec` callbacks.
+//   - No nav wiring — a separate cut adds `r.nav(...)` entries.
+//
+// **Boot-Dependencies:** tenant, tier-engine, billing-foundation.
+import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import { resolveCapUsageRoles } from "./access.js";
+import { CAP_OVERVIEW_FEATURE } from "./constants.js";
+import { createCapsUsageQuery } from "./handlers/caps-usage.query.js";
+import { createTenantCapsListQuery } from "./handlers/tenant-caps-list.query.js";
+import { tenantOptionsQuery } from "./handlers/tenant-options.query.js";
+import { CAP_OVERVIEW_I18N } from "./i18n.js";
+import {
+  createMyCapsScreen,
+  createTenantCapListScreen,
+  platformTenantCapsScreen,
+} from "./screens.js";
+import type { CapSpec } from "./types.js";
+
+export type CreateCapOverviewOptions = {
+  readonly caps: readonly CapSpec[];
+  /** Caps shown as columns on the platform-wide tenant-cap-list screen.
+   *  Defaults to the first three caps when omitted. */
+  readonly listCaps?: readonly string[];
+  /** Options for the tenant-cap-list tier facet. Omitted → no facet — the
+   *  engine itself carries no enumerated tier vocabulary to derive one
+   *  from (see screens.ts doc). "Filter by tier" was explicitly requested;
+   *  omitting `tiers` silently drops that filter, not a supported default. */
+  readonly tiers?: readonly string[];
+  /** Roles that may read their own tenant's usage (`caps:usage` + the my-caps
+   *  screen). Defaults to the admin roles (TenantAdmin, Admin, SystemAdmin);
+   *  list "User"/"Editor" to show usage to regular members. Built-in roles only. */
+  readonly usageVisibleTo?: readonly string[];
+};
+
+export function createCapOverviewFeature(opts: CreateCapOverviewOptions): FeatureDefinition {
+  if (opts.caps.length === 0) {
+    throw new Error("createCapOverviewFeature: `caps` must not be empty.");
+  }
+  const usageRoles = resolveCapUsageRoles(opts.usageVisibleTo);
+  const capIds = new Set(opts.caps.map((cap) => cap.id));
+  const listCaps = opts.listCaps ?? opts.caps.slice(0, 3).map((cap) => cap.id);
+  for (const id of listCaps) {
+    if (!capIds.has(id)) {
+      throw new Error(
+        `createCapOverviewFeature: listCaps references unknown cap id "${id}" — known ids: ${[...capIds].join(", ")}`,
+      );
+    }
+  }
+
+  return defineFeature(CAP_OVERVIEW_FEATURE, (r) => {
+    r.describe(
+      "Read-only visibility into per-tenant tier assignment and cap usage. SystemAdmin gets a platform-wide tenant list with usage bars; tenant admins (or the roles in `usageVisibleTo`) get their own tenant's usage as dashboard cards. Reads tier-engine, billing-foundation, and tenant data plus app-owned usage tables via caller-supplied CapSpec callbacks — never writes.",
+    );
+    r.uiHints({
+      displayLabel: "Cap Overview · Tier & Usage Visibility",
+      category: "operations",
+      recommended: false,
+    });
+    r.systemScope();
+    r.requires("tenant");
+    r.requires("tier-engine");
+    r.requires("billing-foundation");
+
+    r.queryHandler(createTenantCapsListQuery(opts.caps, listCaps));
+    r.queryHandler(createCapsUsageQuery(opts.caps, usageRoles));
+    r.queryHandler(tenantOptionsQuery);
+
+    r.screen(createTenantCapListScreen(opts.caps, listCaps, opts.tiers));
+    r.screen(createMyCapsScreen(usageRoles));
+    r.screen(platformTenantCapsScreen);
+
+    r.translations({ keys: CAP_OVERVIEW_I18N });
+  });
+}

package/packages/bundled-features/src/cap-overview/handlers/caps-usage.query.ts

@@ -0,0 +1,109 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  crossTenantOverrideDenied,
+  defineQueryHandler,
+  type QueryHandlerDefinition,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { tierAssignmentEntity } from "../../tier-engine/index.js";
+import type { CapSpec, CapUsageWithMeta } from "../types.js";
+import { computeFraction, computeTone, computeUnclampedFraction } from "../usage-math.js";
+
+type TierAssignmentRow = { readonly tenantId: string; readonly tier: string };
+
+const tierAssignmentTable = buildEntityTable("tier-assignment", tierAssignmentEntity);
+
+export function createCapsUsageQuery(
+  caps: readonly CapSpec[],
+  usageRoles: readonly string[],
+): QueryHandlerDefinition {
+  return defineQueryHandler({
+    name: "caps:usage",
+    description:
+      "Returns the calling user's own tenant's configured caps with used amount, tier limit and utilisation fraction; use it to answer how close a tenant is to its quota (only SystemAdmin may target another tenant via tenantId).",
+    schema: z.object({ tenantId: z.string().min(1).optional() }),
+    access: { roles: usageRoles },
+    // COUNT/SUM/AVG are covered by TenantDb.count/TenantDb.aggregate; the grant
+    // stays for app-owned CapSpec.usage() providers that still use unsafeRaw.
+    escapeHatch: {
+      reason:
+        "cap-overview:caps:usage — grants app-owned CapSpec.usage() providers that still use unsafeRaw; COUNT/SUM/AVG are covered by TenantDb.count/TenantDb.aggregate",
+    },
+    handler: async (query, ctx) => {
+      if (!ctx.systemDb) {
+        throw new InternalError({
+          message: "cap-overview:query:caps:usage requires ctx.systemDb — is r.systemScope() set?",
+        });
+      }
+      const override = query.payload.tenantId;
+      const overrideDenied = crossTenantOverrideDenied(
+        query.user,
+        override,
+        "cap-overview.errors.tenantOverrideRequiresSystemAdmin",
+      );
+      if (overrideDenied) throw overrideDenied;
+
+      const targetTenantId = override ?? query.user.tenantId;
+      // Both branches return the SAME unfiltered system-mode db —
+      // assertTenantMatch is a self-check on the caller, not a query
+      // filter (see tenant-db.ts). Every read below carries its own
+      // explicit `tenantId` WHERE regardless of which branch ran.
+      const db =
+        override !== undefined
+          ? ctx.systemDb.acknowledgeCrossTenant(
+              `cap-overview:caps:usage — SystemAdmin cross-tenant read for tenant ${targetTenantId}`,
+            )
+          : ctx.systemDb.assertTenantMatch(query.user.tenantId);
+
+      const assignmentRows = await selectMany<TierAssignmentRow>(db, tierAssignmentTable, {
+        tenantId: [targetTenantId],
+      });
+      // Defense-in-depth on the own-tenant path only: assertRowsTenant
+      // checks rows against the CALLER's own tenantId, which is only
+      // meaningful when the caller is reading their own tenant — on the
+      // SystemAdmin override path the target tenant legitimately differs
+      // from the caller's own tenantId, so the check would misfire there.
+      const checkedRows =
+        override === undefined
+          ? ctx.systemDb.assertRowsTenant(assignmentRows, "tenantId")
+          : assignmentRows;
+      const tier = checkedRows[0]?.tier ?? "";
+
+      // Override path: limits must read the TARGET tenant's config, not the
+      // SystemAdmin caller's.
+      const config =
+        override === undefined ? ctx.config : ctx.configFor?.(targetTenantId as TenantId);
+
+      const rows: CapUsageWithMeta[] = await Promise.all(
+        caps.map(async (cap) => {
+          const used = await cap.usage(db, targetTenantId);
+          const limit = await cap.limit(tier, { config });
+          const base = {
+            id: cap.id,
+            label: cap.label,
+            limit,
+            ...(cap.icon !== undefined && { icon: cap.icon }),
+            ...(cap.accentColor !== undefined && { accentColor: cap.accentColor }),
+          };
+          if (used === null) {
+            return { ...base, used: null, fraction: 0, tone: "default" as const, percent: null };
+          }
+          const fraction = computeFraction(used, limit);
+          return {
+            ...base,
+            used,
+            fraction,
+            tone: computeTone(fraction),
+            percent:
+              limit === null ? null : Math.round(computeUnclampedFraction(used, limit) * 100),
+          };
+        }),
+      );
+
+      return { rows };
+    },
+  });
+}

package/packages/bundled-features/src/cap-overview/handlers/tenant-caps-list.query.ts

@@ -0,0 +1,306 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { buildEntityTable, decodeCursor, encodeCursor } from "@cosmicdrift/kumiko-framework/db";
+import {
+  type ConfigAccessor,
+  definePagedQueryHandler,
+  MAX_LIST_LIMIT,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError, ValidationError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { subscriptionsProjectionTable } from "../../billing-foundation/index.js";
+import type { CapLimitContext } from "../../cap-counter/index.js";
+import { tenantTable } from "../../tenant/index.js";
+import { tierAssignmentEntity } from "../../tier-engine/index.js";
+import { capFieldName } from "../constants.js";
+import type { CapSpec, CapUsage } from "../types.js";
+import { computeFraction } from "../usage-math.js";
+
+type TenantRow = { readonly id: string; readonly name: string };
+type TierAssignmentRow = {
+  readonly tenantId: string;
+  readonly tier: string;
+  readonly source: string | null;
+};
+type SubscriptionRow = {
+  readonly tenantId: string;
+  readonly providerName: string;
+  readonly status: string;
+};
+
+type TenantCapsListRow = {
+  readonly tenantId: string;
+  readonly name: string;
+  readonly tier: string;
+  readonly billing: string;
+  readonly [capField: string]: unknown;
+};
+
+// tier-resolver.ts rebuilds the same drizzle table locally rather than
+// importing a pre-built one — tier-engine's public barrel only exports the
+// entity, not a built table (see tier-engine/tier-resolver.ts).
+const tierAssignmentTable = buildEntityTable("tier-assignment", tierAssignmentEntity);
+
+function billingLabel(
+  subscription: SubscriptionRow | undefined,
+  tierSource: string | null,
+): string {
+  if (subscription) return `${subscription.providerName} · ${subscription.status}`;
+  if (tierSource === "manual") return "manual";
+  return "—";
+}
+
+const FILTER_OP = z.enum(["eq", "ne", "lt", "gt", "in"]);
+type FilterOp = z.infer<typeof FILTER_OP>;
+
+const SORTABLE_FIELDS = ["name", "tier", "billing"] as const;
+type SortableField = (typeof SORTABLE_FIELDS)[number];
+
+function tenantCapKey(tenantId: string, capId: string): string {
+  return JSON.stringify([tenantId, capId]);
+}
+
+// One config accessor per tenant: limits may read tenant-scoped config keys, so
+// a limit shared across tenants of the same tier would show the wrong value.
+async function resolveLimitsByTenantAndCap(
+  caps: readonly CapSpec[],
+  tenants: readonly { readonly tenantId: string; readonly tier: string }[],
+  configFor: ((tenantId: TenantId) => ConfigAccessor) | undefined,
+): Promise<ReadonlyMap<string, number | null>> {
+  const entries = await Promise.all(
+    tenants.flatMap(({ tenantId, tier }) => {
+      const context: CapLimitContext = { config: configFor?.(tenantId as TenantId) };
+      return caps.map(
+        async (cap) => [tenantCapKey(tenantId, cap.id), await cap.limit(tier, context)] as const,
+      );
+    }),
+  );
+  return new Map(entries);
+}
+
+function isSortableField(field: string): field is SortableField {
+  return (SORTABLE_FIELDS as readonly string[]).includes(field);
+}
+
+// tier is a plain string with no defined ordering — lt/gt have no meaning
+// on it and are rejected rather than silently treated as "no filter".
+function assertSupportedTierFilterOp(op: FilterOp): void {
+  if (op === "lt" || op === "gt") {
+    throw new ValidationError({
+      fields: [
+        {
+          path: "filters",
+          code: "unsupported_op",
+          i18nKey: "cap-overview.errors.tierFilterOpUnsupported",
+          params: { op },
+        },
+      ],
+    });
+  }
+}
+
+type TierFilterInput = { readonly field: string; readonly op: FilterOp; readonly value: unknown };
+
+function extractTierFilter(filters: readonly TierFilterInput[]): TierFilterInput | undefined {
+  const tierFilters = filters.filter((f) => f.field === "tier");
+  if (tierFilters.length !== filters.length || tierFilters.length > 1) {
+    const unsupportedField = filters.find((f) => f.field !== "tier")?.field ?? "tier";
+    throw new ValidationError({
+      fields: [
+        {
+          path: "filters",
+          code: "unsupported_field",
+          i18nKey: "cap-overview.errors.filterFieldUnsupported",
+          params: { field: unsupportedField },
+        },
+      ],
+    });
+  }
+  const tierFilter = tierFilters[0];
+  if (tierFilter !== undefined) assertSupportedTierFilterOp(tierFilter.op);
+  return tierFilter;
+}
+
+function matchesTierFilter(
+  tier: string,
+  filter: { readonly op: FilterOp; readonly value: unknown } | undefined,
+): boolean {
+  if (filter === undefined) return true;
+  switch (filter.op) {
+    case "eq":
+      return tier === filter.value;
+    case "ne":
+      return tier !== filter.value;
+    case "in":
+      return Array.isArray(filter.value) && filter.value.includes(tier);
+    case "lt":
+    case "gt":
+      // unreachable in practice — assertSupportedTierFilterOp rejects these before this runs
+      return true;
+  }
+}
+
+export function createTenantCapsListQuery(caps: readonly CapSpec[], listCaps: readonly string[]) {
+  const listedCaps = caps.filter((cap) => listCaps.includes(cap.id));
+
+  return definePagedQueryHandler({
+    name: "tenant-caps:list",
+    description:
+      "Lists every tenant on the platform with its tier, billing provider/status and per-cap usage, paged, searchable by name and filterable by tier; use it as the operator-wide capacity overview.",
+    schema: z.object({
+      cursor: z.string().optional(),
+      limit: z.number().int().min(1).max(MAX_LIST_LIMIT).default(50),
+      sort: z.string().optional(),
+      sortDirection: z.enum(["asc", "desc"]).optional(),
+      search: z.string().optional(),
+      filters: z
+        .array(z.object({ field: z.string(), op: FILTER_OP, value: z.unknown() }))
+        .optional(),
+      totalCount: z.boolean().optional(),
+    }),
+    access: { roles: ["SystemAdmin"] },
+    escapeHatch: {
+      reason:
+        "cap-overview:tenant-caps:list — grants app-owned CapSpec.usage()/usageBatch() providers raw SQL for aggregates TenantDb has no typed helper for (e.g. a SUM)",
+    },
+    handler: async (query, ctx) => {
+      if (!ctx.systemDb) {
+        throw new InternalError({
+          message:
+            "cap-overview:query:tenant-caps:list requires ctx.systemDb — is r.systemScope() set?",
+        });
+      }
+      const db = ctx.systemDb.acknowledgeCrossTenant(
+        "cap-overview:tenant-caps:list — SystemAdmin platform-wide tenant overview",
+      );
+
+      const tenants = await selectMany<TenantRow>(db, tenantTable, {});
+      const assignments = await selectMany<TierAssignmentRow>(db, tierAssignmentTable, {});
+      const subscriptions = await selectMany<SubscriptionRow>(db, subscriptionsProjectionTable, {});
+
+      const assignmentByTenant = new Map(assignments.map((row) => [row.tenantId, row]));
+      const subscriptionByTenant = new Map(subscriptions.map((row) => [row.tenantId, row]));
+
+      // Case-insensitive substring search has no `ilike` operator in the
+      // query builder (only `like`, SQL-LIKE case-sensitive) — filtered here
+      // in JS, same as tenant/team-list.query.ts's search.
+      const search = query.payload.search?.trim().toLowerCase();
+      const tierFilter = extractTierFilter(query.payload.filters ?? []);
+
+      const merged = tenants
+        .filter(
+          (tenant) =>
+            search === undefined || search === "" || tenant.name.toLowerCase().includes(search),
+        )
+        .map((tenant) => {
+          const assignment = assignmentByTenant.get(tenant.id);
+          return {
+            tenantId: tenant.id,
+            name: tenant.name,
+            tier: assignment?.tier ?? "",
+            source: assignment?.source ?? null,
+            billing: billingLabel(subscriptionByTenant.get(tenant.id), assignment?.source ?? null),
+          };
+        })
+        .filter((row) => matchesTierFilter(row.tier, tierFilter));
+
+      const sortField = query.payload.sort ?? "name";
+      if (!isSortableField(sortField)) {
+        throw new ValidationError({
+          fields: [
+            {
+              path: "sort",
+              code: "unsupported_field",
+              i18nKey: "cap-overview.errors.sortFieldUnsupported",
+              params: { field: sortField },
+            },
+          ],
+        });
+      }
+      const sortDirection = query.payload.sortDirection ?? "asc";
+      const directionMultiplier = sortDirection === "asc" ? 1 : -1;
+      const sorted = [...merged].sort(
+        (a, b) => a[sortField].localeCompare(b[sortField]) * directionMultiplier,
+      );
+
+      // ponytail: base64-wrapped offset, not a SQL keyset — rows come from a
+      // JS merge of three tables (tenant/tier-assignment/subscription), same
+      // rationale as tenant/team-list.query.ts. Holds up to tier-engine's
+      // documented "single-pass scan" scale (a few thousand tenants); past
+      // that the fix is a real combined read-projection, not a cursor
+      // bolted onto this merge.
+      const offset = query.payload.cursor ? Number(decodeCursor(query.payload.cursor)) : 0;
+      if (!Number.isInteger(offset) || offset < 0) {
+        throw new ValidationError({
+          fields: [
+            {
+              path: "cursor",
+              code: "invalid_cursor",
+              i18nKey: "cap-overview.errors.invalidCursor",
+            },
+          ],
+        });
+      }
+      const limit = query.payload.limit;
+      const page = sorted.slice(offset, offset + limit);
+
+      // Usage is computed only for this page's tenant ids, never for the
+      // full tenant set; caps without usageBatch still cost one query per
+      // tenant of the page, so those run in parallel.
+      const pageTenantIds = page.map((row) => row.tenantId);
+      const usageByCap = new Map<string, Map<string, number | null>>();
+      await Promise.all(
+        listedCaps.map(async (cap) => {
+          if (cap.usageBatch) {
+            usageByCap.set(cap.id, await cap.usageBatch(db, pageTenantIds));
+            // skip: batch result already stored, no per-tenant fallback needed
+            return;
+          }
+          const perTenantEntries = await Promise.all(
+            pageTenantIds.map(
+              async (tenantId) => [tenantId, await cap.usage(db, tenantId)] as const,
+            ),
+          );
+          usageByCap.set(cap.id, new Map(perTenantEntries));
+        }),
+      );
+
+      const limitByTenantAndCap = await resolveLimitsByTenantAndCap(
+        listedCaps,
+        page,
+        ctx.configFor,
+      );
+
+      const rows: TenantCapsListRow[] = page.map((row) => {
+        const capFields: Record<string, CapUsage> = {};
+        for (const cap of listedCaps) {
+          // A tenant absent from the map still means 0 (existing behavior);
+          // only an explicit `null` value means "not measured".
+          const rawUsed = usageByCap.get(cap.id)?.get(row.tenantId);
+          const used = rawUsed === undefined ? 0 : rawUsed;
+          const limit = limitByTenantAndCap.get(tenantCapKey(row.tenantId, cap.id)) ?? null;
+          capFields[capFieldName(cap.id)] =
+            used === null
+              ? { used: null, limit, fraction: 0 }
+              : { used, limit, fraction: computeFraction(used, limit) };
+        }
+        return {
+          tenantId: row.tenantId,
+          name: row.name,
+          tier: row.tier,
+          billing: row.billing,
+          ...capFields,
+        };
+      });
+
+      const nextCursor =
+        offset + limit < sorted.length ? encodeCursor(String(offset + limit)) : null;
+
+      return {
+        rows,
+        nextCursor,
+        ...(query.payload.totalCount === true && { total: merged.length }),
+      };
+    },
+  });
+}

package/packages/bundled-features/src/cap-overview/handlers/tenant-options.query.ts

@@ -0,0 +1,35 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { tenantTable } from "../../tenant/index.js";
+
+type TenantRow = { readonly id: string; readonly name: string };
+
+export const tenantOptionsQuery = defineQueryHandler({
+  name: "tenant-options",
+  description:
+    "Returns all tenants as id/name option pairs sorted by name; use it to populate the tenant picker of a platform-wide overview.",
+  schema: z.object({}),
+  access: { roles: ["SystemAdmin"] },
+  handler: async (_query, ctx) => {
+    if (!ctx.systemDb) {
+      throw new InternalError({
+        message:
+          "cap-overview:query:tenant-options requires ctx.systemDb — is r.systemScope() set?",
+      });
+    }
+    const db = ctx.systemDb.acknowledgeCrossTenant(
+      "cap-overview:tenant-options — SystemAdmin dashboard tenant-filter options",
+    );
+    const tenants = await selectMany<TenantRow>(
+      db,
+      tenantTable,
+      {},
+      {
+        orderBy: { col: "name", direction: "asc" },
+      },
+    );
+    return { rows: tenants.map((tenant) => ({ value: tenant.id, label: tenant.name })) };
+  },
+});

package/packages/bundled-features/src/cap-overview/i18n.ts

@@ -0,0 +1,31 @@
+type LocalizedString = { readonly en: string };
+
+export const CAP_OVERVIEW_I18N: Readonly<Record<string, LocalizedString>> = {
+  "screen:tenant-cap-list.title": { en: "Tenant caps" },
+  "screen:my-caps.title": { en: "My usage" },
+  "screen:platform-tenant-caps.title": { en: "Tenant dashboard" },
+  "cap-overview.list.col.name": { en: "Tenant" },
+  "cap-overview.list.col.tier": { en: "Tier" },
+  "cap-overview.list.col.billing": { en: "Billing" },
+  "cap-overview.list.filter.tier": { en: "Tier" },
+  "cap-overview.list.action.open": { en: "Open dashboard" },
+  "cap-overview.platform.filter.tenant": { en: "Tenant" },
+  "cap-overview.cards.empty": { en: "No caps configured for this tenant." },
+  "cap-overview.cards.loading": { en: "Loading usage…" },
+  "cap-overview.notMeasured": { en: "Not measured yet" },
+  "cap-overview.unlimited": { en: "{used} · unlimited" },
+  "cap-overview.errors.progressPrimitiveMissing": {
+    en: "Usage bar unavailable — Progress primitive is not registered.",
+  },
+  "cap-overview.errors.invalidCursor": { en: "The pagination cursor is invalid." },
+  "cap-overview.errors.filterFieldUnsupported": {
+    en: "Filtering by this field is not supported, or tier was filtered more than once.",
+  },
+  "cap-overview.errors.sortFieldUnsupported": { en: "Sorting by this field is not supported." },
+  "cap-overview.errors.tenantOverrideRequiresSystemAdmin": {
+    en: "Only SystemAdmin may query another tenant's data.",
+  },
+  "cap-overview.errors.tierFilterOpUnsupported": {
+    en: "This filter operator is not supported for tier.",
+  },
+};

package/packages/bundled-features/src/cap-overview/index.ts

@@ -0,0 +1,21 @@
+// Public API of the cap-overview bundled-feature.
+
+export { DEFAULT_CAP_USAGE_ROLES } from "./access.js";
+export {
+  CAP_CARDS_PANEL_COMPONENT,
+  CAP_OVERVIEW_FEATURE,
+  CAP_USAGE_CELL_COMPONENT,
+  CapOverviewQueries,
+  capFieldName,
+  MY_CAPS_SCREEN_ID,
+  PLATFORM_TENANT_CAPS_SCREEN_ID,
+  TENANT_CAP_LIST_SCREEN_ID,
+} from "./constants.js";
+export { type CreateCapOverviewOptions, createCapOverviewFeature } from "./feature.js";
+export {
+  createMyCapsScreen,
+  createTenantCapListScreen,
+  platformTenantCapsScreen,
+} from "./screens.js";
+export type { CapSpec, CapUsage, CapUsageTone, CapUsageWithMeta } from "./types.js";
+export { computeFraction, computeTone } from "./usage-math.js";