@skillcdn/console 0.4.3 → 0.4.5

package/src/plugin/define.ts

@@ -6,6 +6,7 @@
 import type { ArgDefinitions, ArgDescription, ArgsOf } from "./args.js";
 import type {
   CollectionDefinition,
+  CollectionRetention,
   EndpointRequest,
   EndpointResponse,
   PluginContext,
@@ -19,6 +20,7 @@ import {
   MAX_PLUGIN_ENDPOINTS,
   MAX_PLUGIN_INDEXES,
   MAX_PLUGIN_OPERATIONS,
+  MAX_PLUGIN_RETENTION_DAYS,
   MIN_PLUGIN_JOB_INTERVAL_MS,
 } from "./limits.js";
 import {
@@ -103,6 +105,13 @@ export interface CollectionInput<S extends RecordSchema> {
   readonly readOwn?: readonly string[];
   /** A version kept per write; on unless said otherwise. */
   readonly history?: boolean;
+  /**
+   * How long a record is kept: `days` (1 to `MAX_PLUGIN_RETENTION_DAYS`) after the moment `by`
+   * names, `createdAt` unless said, `updatedAt`, or an indexed field holding a day or an instant
+   * as ISO 8601 text. The console removes what is past it, with its versions, links and files;
+   * with `history: false`, a light collection for logs and deliveries. Kept for ever when left out.
+   */
+  readonly retention?: { readonly days: number; readonly by?: string };
 }
 
 /** A collection of records the console keeps for the plugin, by name. */
@@ -154,6 +163,24 @@ export function defineCollection<S extends RecordSchema>(
   if (input.readOwn !== undefined && input.owner === undefined) {
     problems.push(`the collection ${name} has readOwn roles and no owner field`);
   }
+  const retention = input.retention;
+  if (retention !== undefined) {
+    if (
+      !Number.isInteger(retention.days) ||
+      retention.days < 1 ||
+      retention.days > MAX_PLUGIN_RETENTION_DAYS
+    ) {
+      problems.push(
+        `the collection ${name} keeps records for ${String(retention.days)} days; 1 to ${MAX_PLUGIN_RETENTION_DAYS}`,
+      );
+    }
+    const by = retention.by ?? "createdAt";
+    if (by !== "createdAt" && by !== "updatedAt" && !indexes.includes(by)) {
+      problems.push(
+        `the collection ${name} keeps records by ${by}, which is neither createdAt, updatedAt nor an indexed field`,
+      );
+    }
+  }
   fail(problems);
   return Object.freeze({
     name,
@@ -165,6 +192,10 @@ export function defineCollection<S extends RecordSchema>(
     read: Object.freeze([...(input.read ?? [])]),
     readOwn: Object.freeze([...(input.readOwn ?? [])]),
     history: input.history ?? true,
+    retention:
+      input.retention === undefined
+        ? null
+        : Object.freeze({ days: input.retention.days, by: input.retention.by ?? "createdAt" }),
   });
 }
 
@@ -595,6 +626,8 @@ export interface CollectionDescription {
   readonly read: readonly string[];
   readonly readOwn: readonly string[];
   readonly history: boolean;
+  /** How long a record is kept, or `null` for as long as the plugin is; none from a plugin built before it. */
+  readonly retention?: CollectionRetention | null | undefined;
 }
 
 export interface EndpointDescription {
@@ -670,6 +703,7 @@ export function describePlugin(definition: PluginDefinition): PluginDescription
       read: [...collection.read],
       readOwn: [...collection.readOwn],
       history: collection.history,
+      retention: collection.retention ?? null,
     })),
     commands: Object.fromEntries(
       Object.entries(definition.commands).map(([name, command]) => [
@@ -714,6 +748,7 @@ export function descriptionProblems(
   manifest: {
     readonly roles: Readonly<Record<string, unknown>>;
     readonly capabilities: readonly string[];
+    readonly optionalCapabilities?: readonly string[] | undefined;
     readonly settings: readonly { readonly key: string; readonly type: string }[];
     readonly dataVersion: number;
   },
@@ -729,7 +764,9 @@ export function descriptionProblems(
     }
   };
   const needs = (where: string, capability: string) => {
-    if (!manifest.capabilities.includes(capability)) {
+    if (
+      ![...manifest.capabilities, ...(manifest.optionalCapabilities ?? [])].includes(capability)
+    ) {
       problems.push(
         `${where} needs the capability ${capability}, which the manifest does not declare`,
       );

package/src/plugin/limits.ts

@@ -8,11 +8,16 @@ export const MAX_PLUGIN_DESCRIPTION_LENGTH = 200;
 export const MAX_PLUGIN_AGENT_NOTE_LENGTH = 200;
 /** A plugin's key, a role's, a page's, a widget's, a setting's, a collection's, a command's: `^[a-z][a-z0-9-]{1,31}$`. */
 export const MAX_PLUGIN_KEY_LENGTH = 32;
-/** How many roles, settings, pages and widgets one manifest declares. */
+/** How many roles, settings, groups of settings, pages and widgets one manifest declares. */
 export const MAX_PLUGIN_ROLES = 10;
+/** How many other plugins one plugin may ask roles of (ADR-0072). */
+export const MAX_PLUGIN_GRANTS_ASKED = 10;
 export const MAX_PLUGIN_SETTINGS = 50;
+export const MAX_PLUGIN_SETTING_GROUPS = 10;
 export const MAX_PLUGIN_PAGES = 12;
 export const MAX_PLUGIN_WIDGETS = 4;
+/** How many capabilities a plugin asks, the optional ones counted. */
+export const MAX_PLUGIN_CAPABILITIES = 50;
 /** How many collections, commands and queries together, endpoints, and indexes of one collection a server module defines. */
 export const MAX_PLUGIN_COLLECTIONS = 50;
 export const MAX_PLUGIN_OPERATIONS = 100;
@@ -39,6 +44,8 @@ export const MAX_PLUGIN_COMMAND_FILES = 20;
 export const MAX_PLUGIN_EVENT_BYTES = 16 * 1024;
 export const PLUGIN_EVENTS_KEPT = 100_000;
 export const PLUGIN_EVENT_DAYS = 90;
+/** The most days a collection's retention may keep a record: ten years. */
+export const MAX_PLUGIN_RETENTION_DAYS = 3650;
 /** How many records one page of a list carries at most. */
 export const PLUGIN_LIST_LIMIT = 200;
 /** How long plugin code may run: a command; a query or an endpoint; a hook; a job; `onEnable`, `onDisable` and an upgrade. */
@@ -64,7 +71,7 @@ export const MAX_PLUGIN_SQL_ROWS = 10_000;
 export const PLUGIN_SQL_CONNECTIONS = 4;
 /** The memory a plugin's thread may hold, in megabytes, where the deployment says nothing. */
 export const DEFAULT_PLUGIN_MEMORY_MB = 256;
-/** How tall a widget's frame may grow, in pixels. */
+/** How tall a widget's frame grew, in pixels, before a widget had sizes of a family (ADR-0059); kept for the readers of before, read by nothing. */
 export const MAX_PLUGIN_WIDGET_HEIGHT = 480;
 /** How many retries a hook gets before its event is skipped with a `plugin.failed` event. */
 export const PLUGIN_HOOK_RETRIES = 5;

package/src/plugin/manifest.ts

@@ -8,14 +8,18 @@ import {
   MAX_PROJECT_NAME_LENGTH,
 } from "../limits.js";
 import { hasForbiddenCodePoint } from "../text.js";
+import { PLUGIN_WIDGET_SIZE_NAMES, type PluginWidgetSizeName } from "./bridge.js";
 import { isPluginCapability } from "./capabilities.js";
 import {
   MAX_PLUGIN_AGENT_NOTE_LENGTH,
+  MAX_PLUGIN_CAPABILITIES,
   MAX_PLUGIN_DESCRIPTION_LENGTH,
+  MAX_PLUGIN_GRANTS_ASKED,
   MAX_PLUGIN_NAME_LENGTH,
   MAX_PLUGIN_OPTIONS,
   MAX_PLUGIN_PAGES,
   MAX_PLUGIN_ROLES,
+  MAX_PLUGIN_SETTING_GROUPS,
   MAX_PLUGIN_SETTINGS,
   MAX_PLUGIN_WIDGETS,
 } from "./limits.js";
@@ -135,6 +139,7 @@ export const PLUGIN_SETTING_TYPES = [
   "boolean",
   "enum",
   "day",
+  "time",
   "person",
   "project",
   "secret",
@@ -149,14 +154,89 @@ export type PluginPageLevel = (typeof PLUGIN_PAGE_LEVELS)[number];
 export const PLUGIN_WIDGET_PLACES = ["home:top", "home:bottom"] as const;
 export type PluginWidgetPlace = (typeof PLUGIN_WIDGET_PLACES)[number];
 
+/** The sizes of before (ADR-0054), each read as one of the family (ADR-0059): a third as small, a half as medium, the width as wide. */
 export const PLUGIN_WIDGET_SIZES = ["third", "half", "full"] as const;
 export type PluginWidgetSize = (typeof PLUGIN_WIDGET_SIZES)[number];
 
+export { PLUGIN_WIDGET_SIZE_NAMES, type PluginWidgetSizeName };
+
+const LEGACY_WIDGET_SIZES: Readonly<Record<PluginWidgetSize, PluginWidgetSizeName>> = {
+  third: "small",
+  half: "medium",
+  full: "wide",
+};
+
+/** The columns and the rows of the front page's grid of square cells each size takes (ADR-0061). */
+export const PLUGIN_WIDGET_SIZE_CELLS: Readonly<
+  Record<PluginWidgetSizeName, { readonly columns: number; readonly rows: number }>
+> = {
+  small: { columns: 2, rows: 2 },
+  medium: { columns: 4, rows: 2 },
+  large: { columns: 4, rows: 4 },
+  wide: { columns: 8, rows: 2 },
+  full: { columns: 8, rows: 4 },
+};
+
+/** The most cells across a phone's grid has; a widget comes in a size that fits it (ADR-0062). */
+const PLUGIN_WIDGET_PHONE_COLUMNS = 4;
+
+/** Whether a size fits a phone's grid. */
+const fitsPhone = (size: PluginWidgetSizeName): boolean =>
+  PLUGIN_WIDGET_SIZE_CELLS[size].columns <= PLUGIN_WIDGET_PHONE_COLUMNS;
+
+/**
+ * The sizes a widget comes in and the one it starts at: `sizes` and `defaultSize` where the
+ * manifest declares them, else the one size of before read as one of the family, with a size a
+ * phone can hold beside it where that one is too wide.
+ */
+export function widgetSizesOf(widget: {
+  readonly size?: PluginWidgetSize | undefined;
+  readonly sizes?: readonly PluginWidgetSizeName[] | undefined;
+  readonly defaultSize?: PluginWidgetSizeName | undefined;
+}): {
+  readonly sizes: readonly PluginWidgetSizeName[];
+  readonly defaultSize: PluginWidgetSizeName;
+} {
+  if (widget.sizes !== undefined && widget.sizes.length > 0) {
+    return { sizes: widget.sizes, defaultSize: widget.defaultSize ?? widget.sizes[0] ?? "small" };
+  }
+  const one = LEGACY_WIDGET_SIZES[widget.size ?? "third"];
+  return { sizes: fitsPhone(one) ? [one] : ["medium", one], defaultSize: one };
+}
+
+/** The size of before nearest to one of the family, for a reader of before. */
+export function legacyWidgetSize(size: PluginWidgetSizeName): PluginWidgetSize {
+  return size === "small" ? "third" : size === "medium" || size === "large" ? "half" : "full";
+}
+
 export const PLUGIN_BOARD_NEEDS = ["required", "optional", "none"] as const;
 export type PluginBoardNeeds = (typeof PLUGIN_BOARD_NEEDS)[number];
 
 const LANGUAGE_TAG = /^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/;
-const DAY = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
+const DAY = /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+
+/**
+ * True for a day as `YYYY-MM-DD` that the calendar has: February 30 and April 31 fit the shape
+ * and are no day, and a date made from them comes back as another day.
+ */
+export function isCalendarDay(value: unknown): value is string {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const match = DAY.exec(value);
+  if (match === null) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return (
+    date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day
+  );
+}
+/** A time of day as `HH:MM`, read in the workspace's time zone. */
+export const TIME_OF_DAY = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
 /** A path within the package: relative, forward slashes, never climbing out. */
 const PACKAGE_PATH = /^(?!\/)(?!\.\.(?:\/|$))(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+$/;
 /** A semver range as npm spells one, loosely: the console compares versions, the registry resolves. */
@@ -230,6 +310,12 @@ const pluginSettingSchema = z
       z.array(settingOption).check(z.minLength(1), z.maxLength(MAX_PLUGIN_OPTIONS)),
     ),
     of: z.optional(settingItemType),
+    /** The group of `settingGroups` the setting is shown under; left out, above every group. */
+    group: z.optional(key),
+    /** For a `secret`: the hosts it may be put into a request to and sealed from the answers of (`slack.com`, `*.example.com`), and no other; any host the plugin may reach when left out. */
+    hosts: z.optional(z.array(z.string().check(z.maxLength(300))).check(z.maxLength(20))),
+    /** For a `secret`: `verify`, a secret that verifies signatures and signs nothing, so that a request cannot be forged with it. */
+    use: z.optional(z.literal("verify")),
   })
   .check(
     z.superRefine((setting, ctx) => {
@@ -241,6 +327,15 @@ const pluginSettingSchema = z
 
 export type PluginSetting = z.infer<typeof pluginSettingSchema>;
 
+/** A group the settings form is divided into: a panel with a name and, where given, a word under it. */
+const pluginSettingGroupSchema = z.strictObject({
+  key,
+  name: localized(MAX_PLUGIN_NAME_LENGTH),
+  description: z.optional(localized(MAX_PLUGIN_DESCRIPTION_LENGTH)),
+});
+
+export type PluginSettingGroup = z.infer<typeof pluginSettingGroupSchema>;
+
 /** True when `value` is what a setting of `type` holds, `options` being the values of an `enum`. */
 function fitsSettingType(
   type: Exclude<PluginSettingType, "secret" | "list">,
@@ -258,7 +353,9 @@ function fitsSettingType(
     case "enum":
       return typeof value === "string" && (options ?? []).includes(value);
     case "day":
-      return typeof value === "string" && DAY.test(value);
+      return isCalendarDay(value);
+    case "time":
+      return typeof value === "string" && TIME_OF_DAY.test(value);
     case "person":
     case "project":
       return false;
@@ -274,8 +371,18 @@ function settingProblems(setting: {
   max?: number;
   options?: readonly { value: string }[];
   of?: Exclude<PluginSettingType, "secret" | "list">;
+  hosts?: readonly string[];
+  use?: "verify";
 }): string[] {
   const problems: string[] = [];
+  if (setting.type !== "secret" && (setting.hosts !== undefined || setting.use !== undefined)) {
+    problems.push(`only a secret takes hosts or use`);
+  }
+  for (const host of setting.hosts ?? []) {
+    if (!isPluginCapability(`outbound:${host}`) || host === "webrtc") {
+      problems.push(`the host "${host}" is not a host as outbound:<host> names one`);
+    }
+  }
   const bounded =
     setting.type === "number" ||
     setting.type === "text" ||
@@ -334,16 +441,60 @@ const pluginPageSchema = z.strictObject({
 
 export type PluginPage = z.infer<typeof pluginPageSchema>;
 
-const pluginWidgetSchema = z.strictObject({
-  key,
-  name: localized(MAX_PLUGIN_NAME_LENGTH),
-  place: z.enum(PLUGIN_WIDGET_PLACES),
-  size: z.enum(PLUGIN_WIDGET_SIZES),
-  roles: z.optional(roleList),
-});
+const pluginWidgetSchema = z
+  .strictObject({
+    key,
+    name: localized(MAX_PLUGIN_NAME_LENGTH),
+    place: z.enum(PLUGIN_WIDGET_PLACES),
+    /** The one size of before; `sizes` says it better. */
+    size: z.optional(z.enum(PLUGIN_WIDGET_SIZES)),
+    /** The sizes the widget comes in (ADR-0059), each once; the person picks among them. */
+    sizes: z.optional(
+      z.array(z.enum(PLUGIN_WIDGET_SIZE_NAMES)).check(z.minLength(1), z.maxLength(5)),
+    ),
+    /** The size it starts at, one of `sizes`; the first of them when left out. */
+    defaultSize: z.optional(z.enum(PLUGIN_WIDGET_SIZE_NAMES)),
+    roles: z.optional(roleList),
+  })
+  .check(
+    z.superRefine((widget, ctx) => {
+      if (widget.size === undefined && widget.sizes === undefined) {
+        ctx.addIssue({
+          code: "custom",
+          message: "needs sizes, the sizes it comes in",
+          input: widget,
+        });
+      }
+      if (widget.sizes !== undefined && new Set(widget.sizes).size !== widget.sizes.length) {
+        ctx.addIssue({ code: "custom", message: "sizes names a size twice", input: widget });
+      }
+      if (widget.sizes !== undefined && !widget.sizes.some(fitsPhone)) {
+        ctx.addIssue({
+          code: "custom",
+          message: "sizes needs small, medium or large: a phone's grid is four cells across",
+          input: widget,
+        });
+      }
+      if (widget.defaultSize !== undefined && !(widget.sizes ?? []).includes(widget.defaultSize)) {
+        ctx.addIssue({
+          code: "custom",
+          message: "defaultSize is not one of sizes",
+          input: widget,
+        });
+      }
+    }),
+  );
 
 export type PluginWidget = z.infer<typeof pluginWidgetSchema>;
 
+/** Every capability a plugin asks: those it needs, then those it can go without (ADR-0060). */
+export function capabilitiesAsked(manifest: {
+  readonly capabilities: readonly string[];
+  readonly optionalCapabilities?: readonly string[] | undefined;
+}): string[] {
+  return [...manifest.capabilities, ...(manifest.optionalCapabilities ?? [])];
+}
+
 const pluginMenuSchema = z
   .strictObject({
     group: key,
@@ -388,6 +539,11 @@ export type PluginBoard = z.infer<typeof pluginBoardSchema>;
 const pluginRoleSchema = z.strictObject({
   name: localized(MAX_PLUGIN_NAME_LENGTH),
   description: localized(MAX_PLUGIN_DESCRIPTION_LENGTH),
+  /**
+   * A role held by what a person is in the directory, with no grant (ADR-0068): `reports`,
+   * whoever someone active reports to, read from the directory on every call.
+   */
+  follows: z.optional(z.literal("reports")),
 });
 
 export type PluginRole = z.infer<typeof pluginRoleSchema>;
@@ -409,12 +565,19 @@ export const pluginManifestSchema = z
     description: localized(MAX_PLUGIN_DESCRIPTION_LENGTH),
     agentNote: z.optional(localized(MAX_PLUGIN_AGENT_NOTE_LENGTH)),
     pluginApi: z.int().check(z.positive()),
+    /** The consoles the plugin runs on, as a semver range of the console's version; left out, any console that serves `pluginApi`. */
+    console: z.optional(z.string().check(z.regex(SEMVER_RANGE, "is a semver range"))),
     server: packagePath,
     web: z.optional(packagePath),
     skills: z.optional(packagePath),
     migrations: z.optional(packagePath),
     capabilities: z._default(
-      z.array(z.string().check(z.maxLength(300))).check(z.maxLength(50)),
+      z.array(z.string().check(z.maxLength(300))).check(z.maxLength(MAX_PLUGIN_CAPABILITIES)),
+      [],
+    ),
+    /** What the plugin can go without (ADR-0060): an administrator turns each on, or leaves it off. */
+    optionalCapabilities: z._default(
+      z.array(z.string().check(z.maxLength(300))).check(z.maxLength(MAX_PLUGIN_CAPABILITIES)),
       [],
     ),
     roles: z._default(z.record(key, pluginRoleSchema), {}),
@@ -423,8 +586,26 @@ export const pluginManifestSchema = z
       z.record(key, z.string().check(z.regex(SEMVER_RANGE, "is a semver range"))),
       {},
     ),
+    /**
+     * The roles of other plugins the plugin asks to hold (ADR-0072), by their key, each with why,
+     * for the administrator who grants them: shown when enabling and on the plugin's page.
+     */
+    grants: z._default(
+      z.record(
+        key,
+        z.strictObject({
+          roles: z.array(key).check(z.minLength(1), z.maxLength(MAX_PLUGIN_ROLES)),
+          why: localized(MAX_PLUGIN_DESCRIPTION_LENGTH),
+        }),
+      ),
+      {},
+    ),
     board: z._default(pluginBoardSchema, { needs: "none" }),
     settings: z._default(z.array(pluginSettingSchema).check(z.maxLength(MAX_PLUGIN_SETTINGS)), []),
+    settingGroups: z._default(
+      z.array(pluginSettingGroupSchema).check(z.maxLength(MAX_PLUGIN_SETTING_GROUPS)),
+      [],
+    ),
     menu: z.optional(pluginMenuSchema),
     pages: z._default(z.array(pluginPageSchema).check(z.maxLength(MAX_PLUGIN_PAGES)), []),
     widgets: z._default(z.array(pluginWidgetSchema).check(z.maxLength(MAX_PLUGIN_WIDGETS)), []),
@@ -433,7 +614,17 @@ export const pluginManifestSchema = z
   })
   .check(
     z.superRefine((manifest, ctx) => {
-      for (const problem of manifestProblems(manifest)) {
+      for (const problem of [
+        ...manifestProblems(manifest),
+        ...(manifest.key in manifest.grants ? ["grants: a plugin asks nothing of itself"] : []),
+        // Its own api through `ctx.plugins` would be itself called as another plugin, and, with
+        // `people:act`, every call of its own made for anyone (ADR-0072).
+        ...(capabilitiesAsked(manifest).includes(`plugins:${manifest.key}`)
+          ? [
+              `capabilities: plugins:${manifest.key} is the plugin itself; a plugin calls no api of its own`,
+            ]
+          : []),
+      ]) {
         ctx.addIssue({ code: "custom", message: problem, input: manifest });
       }
     }),
@@ -462,15 +653,30 @@ function manifestProblems(
   if (roles.length > MAX_PLUGIN_ROLES) {
     problems.push(`declares ${roles.length} roles; ${MAX_PLUGIN_ROLES} at most`);
   }
+  const pluginsAsked = Object.keys(manifest.grants);
+  if (pluginsAsked.length > MAX_PLUGIN_GRANTS_ASKED) {
+    problems.push(
+      `asks roles of ${pluginsAsked.length} plugins; ${MAX_PLUGIN_GRANTS_ASKED} at most`,
+    );
+  }
   if (manifest.defaultRole !== undefined && !roles.includes(manifest.defaultRole)) {
     problems.push(`defaultRole ${manifest.defaultRole} is not a declared role`);
   }
-  for (const capability of manifest.capabilities) {
+  const asked = capabilitiesAsked(manifest);
+  if (asked.length > MAX_PLUGIN_CAPABILITIES) {
+    problems.push(`capabilities: at most ${MAX_PLUGIN_CAPABILITIES}, the optional ones counted`);
+  }
+  if (manifest.optionalCapabilities.includes("storage:sql")) {
+    problems.push(
+      "optionalCapabilities: storage:sql cannot be optional: its schema is made when the plugin is enabled",
+    );
+  }
+  for (const capability of asked) {
     if (!isPluginCapability(capability)) {
       problems.push(`capabilities: ${capability} is not one the console knows`);
     }
   }
-  for (const capability of duplicates(manifest.capabilities)) {
+  for (const capability of duplicates(asked)) {
     problems.push(`capabilities: ${capability} is declared twice`);
   }
   const undeclared = (where: string, named: readonly string[] | undefined) => {
@@ -490,11 +696,20 @@ function manifestProblems(
     ["pages", manifest.pages.map((page) => page.key)],
     ["widgets", manifest.widgets.map((widget) => widget.key)],
     ["settings", manifest.settings.map((setting) => setting.key)],
+    ["settingGroups", manifest.settingGroups.map((group) => group.key)],
   ] as const) {
     for (const twice of duplicates(keys)) {
       problems.push(`${what}: ${twice} is declared twice`);
     }
   }
+  const groups = manifest.settingGroups.map((group) => group.key);
+  for (const setting of manifest.settings) {
+    if (setting.group !== undefined && !groups.includes(setting.group)) {
+      problems.push(
+        `settings.${setting.key} names the group ${setting.group}, which settingGroups does not declare`,
+      );
+    }
+  }
   if ((manifest.pages.length > 0 || manifest.widgets.length > 0) && manifest.web === undefined) {
     problems.push("pages and widgets need web, the directory of the bundle");
   }