dsh-web-search-pro 0.2.0 → 0.2.3

package/lib/types/client/order.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The pure side of the "Search order" group: the lists it edits (engines, the backend chain of a platform), the sources one can
+ * add to them, what a source is called and whether the card can tell it is ready, and the edits as text patches. No Host, no DOM:
+ * the editors call these and stage the resulting text into the form model, the tests call the same functions.
+ * @module web-search-pro/client/order
+ */
+import { type SourceDef } from './field-keys.ts';
+/** Dictionary-independent facts the list rows show; the names are proper names, the same in every language. */
+export type SourceKind = 'keyed' | 'anonymous' | 'seam' | 'custom' | 'unknown';
+export interface SourceInfo {
+    id: string;
+    name: string;
+    kind: SourceKind;
+    /** The row of the sources list this source is (key reference, request budget), when it has one. */
+    def?: SourceDef;
+}
+/** The ctx.web engine of the Host: the default `engines` list names it (`seam`). */
+export declare const SEAM_SOURCE: {
+    readonly id: "seam";
+    readonly name: "ctx.web (seam)";
+};
+/** The route ids a general engine list may name: every keyed and anonymous source of the card, plus the ctx.web engine. */
+export declare const BUILTIN_ENGINE_IDS: readonly string[];
+/** Id of a custom CLI as `engines` and `platformBackends` write it. */
+export declare const customId: (id: string) => string;
+export declare const isCustomId: (id: string) => boolean;
+/** The custom CLI entries of the (staged) `cliAdapters` value, by id, in the order they were written. */
+export declare function customEntries(cliAdapters: unknown): [string, Record<string, unknown>][];
+/** What the list needs to know of a source id: its name and what kind it is. `cliAdapters` is the staged value (custom ids are looked up in it). */
+export declare function sourceInfo(id: string, cliAdapters?: unknown): SourceInfo;
+/** The ids of a list value written as comma-separated text (`engines`), de-duplicated, in order. */
+export declare const idsOf: (text: string) => string[];
+/** The text form of a list of ids. */
+export declare const textOf: (ids: readonly string[]) => string;
+export declare function addId(ids: readonly string[], id: string): string[];
+export declare function removeId(ids: readonly string[], id: string): string[];
+/** Move `id` one place towards the front (`-1`) or the back (`1`); at an end, or when absent, the list comes back unchanged. */
+export declare function moveId(ids: readonly string[], id: string, delta: -1 | 1): string[];
+/**
+ * The sources that can be added to the general engine list: the built-in ones and the custom CLIs marked `engine`, those already in
+ * the list left out. A custom CLI whose spec is invalid is not offered (the server would not register it).
+ */
+export declare function engineChoices(current: readonly string[], cliAdapters: unknown): string[];
+/** Display names of the platforms that have a backend chain (proper names; the ids are what `platformBackends` is keyed by). */
+export declare const PLATFORM_NAMES: Readonly<Record<string, string>>;
+/** Display names of the fixed (non-CLI) backends. */
+export declare const BACKEND_NAMES: Readonly<Record<string, string>>;
+/** The platforms the card lists: every one with a backend chain. */
+export declare const ORDER_PLATFORMS: readonly string[];
+/** The built-in default chain of a platform. */
+export declare const defaultChainOf: (platform: string) => readonly string[];
+/**
+ * The backends that can sit in the chain of `platform`: the built-in ones that serve it (CLI specs and the fixed backends) and the
+ * custom CLIs whose spec declares the platform; those already in `current` are left out.
+ */
+export declare function backendChoices(platform: string, current: readonly string[], cliAdapters: unknown): string[];
+/** The name a backend row shows: the fixed backends and custom CLIs by name, a CLI spec by its command. */
+export declare function backendName(id: string): string;
+/** The `platformBackends` value of the staged text as an object (undefined when it is empty or not an object). */
+export declare function chainsOf(text: string): Record<string, string[]> | undefined;
+/**
+ * `platformBackends` text with the chain of `platform` set to `ids`, or the platform's key removed (`ids` undefined: back to the
+ * default chain). Other platforms, and keys this card does not know, are kept as they were. The empty object comes back as
+ * the empty text, which the form model stores as "not set".
+ */
+export declare function withChain(text: string, platform: string, ids: readonly string[] | undefined): string | undefined;
+export interface CustomRow {
+    id: string;
+    bin: string;
+    engine: boolean;
+    platforms: string[];
+    confidence: number;
+    /** The validation problems of the entry (empty = the spec is valid and the server registers it). */
+    problems: string[];
+}
+/** One row per custom CLI of the staged `cliAdapters` value: what the list shows, with the server's own validation. */
+export declare function customRows(cliAdapters: unknown): CustomRow[];
+/** The platforms people reach for most: listed even when nothing was changed for them. */
+export declare const COMMON_PLATFORMS: readonly string[];
+/**
+ * Which platforms the list shows up front, and which fold into "show the rest": a platform is shown when its chain was changed
+ * (`platformBackends` has its key), when a valid custom CLI declares it, or when it is one of the common ones. Both halves keep the
+ * order of `platforms`. `platformBackends` is the staged text; when it is not valid JSON nothing counts as changed.
+ */
+export declare function splitPlatforms(platforms: readonly string[], platformBackends: string, cliAdapters: unknown): {
+    shown: string[];
+    rest: string[];
+};
+/** The platforms whose display name or id contains `query` (case-insensitive, surrounding spaces ignored); an empty query keeps all. */
+export declare function filterPlatforms(platforms: readonly string[], query: string): string[];
+export interface ConfidenceView {
+    /** The value the row runs with: the typed override when it is a number, else the source's default. */
+    effective: number;
+    /** The text is not a number in 0-1. */
+    invalid: boolean;
+    /** Whether the row has its own value in the draft (the box is not empty). */
+    typed: boolean;
+    /** The value changes nothing (it is 1) and is not wrong: the row shows it as a quiet "default" until someone opens it. */
+    quiet: boolean;
+}
+/** What the confidence box of a row shows, from the staged text of `sources.confidence.<id>` and the default of the source. */
+export declare function confidenceView(text: string, defaultValue: number): ConfidenceView;

package/lib/types/client/overlay-ops.d.ts

@@ -0,0 +1,37 @@
+/**
+ * What "Adopt into configuration" writes, and the small formatting the agent section needs. Pure and free of the Host: the
+ * controller calls these, the tests call the same functions.
+ *
+ * Adopting an overlay entry means the user takes the agent's value as their own: it is written into the profile (the baseline) with
+ * the same atomic `mutate` the save bar uses, at the leaf the entry is about (`sources.confidence.<id>`, `cliAdapters.<id>`,
+ * `platformBackends.<platform>`, `engines`, `sources.priority`, `sources.disabled`), and only then is the overlay entry dropped, so there
+ * is never a moment when the value is in neither place. Revoking only drops the entry.
+ * @module web-search-pro/client/overlay-ops
+ */
+import type { OverlayItem } from '../overlay-types.ts';
+export type SectionOp = {
+    op: 'set';
+    path: string[];
+    value: unknown;
+} | {
+    op: 'unset';
+    path: string[];
+};
+export interface Adoption {
+    /** The Host ops that write the value into the configuration. */
+    ops: SectionOp[];
+    /** Card fields whose staged draft the adopted value replaces (the draft would otherwise be shown against a changed baseline). */
+    drop: string[];
+}
+/** The ops that write an overlay item into the configuration; undefined for a key that is none of the overridable ones. */
+export declare function adoptionOf(item: Pick<OverlayItem, 'kind' | 'target' | 'value'>): Adoption | undefined;
+/** The overlay key a card field is the baseline of (the row that shows it carries the "changed by the agent" mark), or undefined. */
+export declare function overlayKeyOfField(field: string): string | undefined;
+/** `2026-10-27 22:35` in the viewer's time zone; the text itself when it is no date. */
+export declare function formatTime(iso: string): string;
+/**
+ * The custom CLIs an overlay item leans on that only the overlay holds: an engine list or a platform chain that names `custom-cli:<id>`
+ * where `cliAdapters.<id>` is itself an overlay entry. Adopting such an item alone would leave the configuration naming a CLI it does not
+ * define, so the card says to adopt the CLI too.
+ */
+export declare function overlayCliDependencies(item: Pick<OverlayItem, 'kind' | 'value'>, items: readonly Pick<OverlayItem, 'key'>[]): string[];

package/lib/types/client/styles.d.ts

@@ -1,56 +1,71 @@
 export declare const styles: {
-    readonly card: "wsp-card";
-    readonly cardOpen: "wsp-card-open";
-    readonly header: "wsp-header";
-    readonly headText: "wsp-head-text";
-    readonly titleRow: "wsp-title-row";
-    readonly name: "wsp-name";
-    readonly description: "wsp-description";
-    readonly dirtyBadge: "wsp-dirty-badge";
-    readonly chevron: "wsp-chevron";
-    readonly chevronOpen: "wsp-chevron-open";
-    readonly body: "wsp-body";
     readonly notice: "wsp-notice";
-    readonly section: "wsp-section";
-    readonly sectionHeading: "wsp-section-heading";
-    readonly grid: "wsp-grid";
     readonly field: "wsp-field";
-    readonly fieldInvalid: "wsp-field-invalid";
-    readonly fieldHeading: "wsp-field-heading";
+    readonly fieldHead: "wsp-field-head";
     readonly label: "wsp-label";
     readonly hint: "wsp-hint";
     readonly input: "wsp-input";
     readonly textarea: "wsp-textarea";
     readonly code: "wsp-code";
-    readonly reset: "wsp-reset";
-    readonly toggleField: "wsp-toggle-field";
-    readonly toggleLabel: "wsp-toggle-label";
-    readonly toggleCopy: "wsp-toggle-copy";
-    readonly checkbox: "wsp-checkbox";
-    readonly secretRow: "wsp-secret-row";
-    readonly credentialStatus: "wsp-credential-status";
-    readonly advanced: "wsp-advanced";
-    readonly advancedHint: "wsp-advanced-hint";
-    readonly footer: "wsp-footer";
-    readonly status: "wsp-status";
     readonly failed: "wsp-failed";
     readonly actions: "wsp-actions";
-    readonly secondaryButton: "wsp-secondary-button";
-    readonly primaryButton: "wsp-primary-button";
+    readonly root: "wsp-root";
+    readonly summaryBar: "wsp-summary";
+    readonly chips: "wsp-chips";
+    readonly chip: "wsp-chip";
+    readonly chipRemove: "wsp-chip-remove";
+    readonly chipInput: "wsp-chip-input";
+    readonly group: "wsp-group";
+    readonly groupHead: "wsp-group-head";
+    readonly groupTitle: "wsp-group-title";
+    readonly groupSub: "wsp-group-sub";
+    readonly groupBadges: "wsp-group-badges";
+    readonly groupBody: "wsp-group-body";
+    readonly row: "wsp-row";
+    readonly rowText: "wsp-row-text";
+    readonly rowLabel: "wsp-row-label";
+    readonly rowControl: "wsp-row-control";
+    readonly rowHint: "wsp-row-hint";
+    readonly rowMeta: "wsp-row-meta";
+    readonly muted: "wsp-muted";
     readonly select: "wsp-select";
-    readonly problem: "wsp-problem";
-    readonly warning: "wsp-warning";
-    readonly sectionSummary: "wsp-section-summary";
-    readonly sectionBody: "wsp-section-body";
-    readonly subheading: "wsp-subheading";
+    readonly unitInput: "wsp-unit-input";
+    readonly unit: "wsp-unit";
+    readonly help: "wsp-help";
+    readonly link: "wsp-link";
+    readonly danger: "wsp-danger";
+    readonly list: "wsp-list";
+    readonly item: "wsp-item";
+    readonly itemMain: "wsp-item-main";
+    readonly itemTitle: "wsp-item-title";
+    readonly itemMeta: "wsp-item-meta";
+    readonly itemActions: "wsp-item-actions";
+    readonly empty: "wsp-empty";
+    readonly subHead: "wsp-sub-head";
+    readonly compare: "wsp-compare";
+    readonly compareCol: "wsp-compare-col";
+    readonly preview: "wsp-preview";
+    readonly savebar: "wsp-savebar";
+    readonly saveText: "wsp-save-text";
+    readonly dialogBody: "wsp-dialog-body";
+    readonly stack: "wsp-stack";
+    readonly fold: "wsp-fold";
+    readonly foldBody: "wsp-fold-body";
+    readonly foldHint: "wsp-fold-hint";
+    readonly invalidInput: "wsp-invalid-input";
+    readonly secretRow: "wsp-secret-row";
     readonly codeBlock: "wsp-code-block";
-    readonly note: "wsp-note";
     readonly table: "wsp-table";
-    readonly rubric: "wsp-rubric";
-    readonly rubricHead: "wsp-rubric-head";
-    readonly badge: "wsp-badge";
-    readonly fullRow: "wsp-full-row";
-    readonly keyedSource: "wsp-keyed-source";
-    readonly linkButton: "wsp-link-button";
+    readonly chain: "wsp-chain";
+    readonly why: "wsp-why";
+    readonly orderBar: "wsp-order-bar";
+    readonly tokens: "wsp-tokens";
+    readonly tokenRow: "wsp-token-row";
+    readonly trialOut: "wsp-trial-out";
+    readonly trialBar: "wsp-trial-bar";
 };
+/**
+ * Inject the card's stylesheet, or refresh it in place. A Host that hot-reloads the plugin keeps the page (and the
+ * `<style>` an older version injected), so an existing element gets the current CSS instead of being kept as is.
+ */
 export declare function ensureStyles(): void;

package/lib/types/client/text-view.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The "Advanced: text mode" view: the plugin's settings as one commented YAML text. It is a read-only print of the controls'
+ * staged state, not a second place the settings live. Every key has a comment in front of it (see field-docs.ts); keys you have
+ * overridden are plain lines, the others are commented `# key: value` lines showing the value in force; secrets never appear
+ * (only the names of the credentials that hold them). Comment lines start with `#`, so stripping them leaves exactly the
+ * overrides as valid YAML.
+ * @module web-search-pro/client/text-view
+ */
+import { type DocLang } from './field-docs.ts';
+import { type FieldSpec, type Json } from './form-specs.ts';
+interface FieldView {
+    text: string;
+    overridden: boolean;
+}
+/**
+ * The text of the card's current (staged) settings in `lang`. `views` is the staged text and override flag of every field, as the
+ * card state carries them; `specs` are the field specs of the form model.
+ */
+export declare function renderTextView(views: Readonly<Record<string, FieldView | undefined>>, specs: readonly FieldSpec[], lang?: DocLang | string): string;
+/** The text of the lines that are data: every comment line and blank line dropped (what a YAML reader sees). */
+export declare function stripComments(text: string): string;
+export type { Json };

package/lib/types/client/ui-kit.d.ts

@@ -0,0 +1,200 @@
+/**
+ * The small set of controls the settings card is made of.
+ *
+ * Switches, buttons, badges, dialogs and the click-to-read help bubble are the Host's own
+ * (`@deepseek-ai/dsh-client-ui-primitives`). The Host ships no select, no chip input, no accordion and no
+ * list-row, so those four are built here from native elements (`<select>`, `<details>`, `<input>`) and the
+ * `--dsw-alias-*` tokens, which makes them follow the light and dark themes without a color of their own.
+ * Nothing in this file knows about a configuration field: callers pass text and callbacks.
+ * @module web-search-pro/client/ui-kit
+ */
+import { type ReactNode } from 'react';
+export type Tone = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'outline';
+/** A read-only badge. */
+export declare function Badge(props: {
+    tone?: Tone;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The mark of a setting an agent changed: a warning badge whose tooltip carries the value, the reason and the time. */
+export declare function AgentTag(props: {
+    label: string;
+    tip: string;
+}): import("react").JSX.Element;
+/** The `?` button: its text opens on click, so a long explanation costs one glyph until someone asks. */
+export declare function Help(props: {
+    label: string;
+    text: string;
+}): import("react").JSX.Element;
+/** Labels every row shares, so a row does not need the dictionary itself. */
+export interface RowLabels {
+    overridden: string;
+    reset: string;
+    help: string;
+    invalid: string;
+}
+export interface RowProps {
+    /** The configuration field this row is the entry of (one per public field; the render test counts them). */
+    field?: string;
+    /** The id of the control, so the label is tied to it. */
+    id?: string;
+    label: string;
+    /** One short sentence. Anything longer belongs in `help`. */
+    hint?: string;
+    help?: string;
+    overridden?: boolean;
+    invalid?: boolean;
+    /** Replaces the hint while the value is invalid. */
+    problem?: string;
+    /** Accepted, but unlikely to do what was meant: a second line under the hint. */
+    warning?: string;
+    /** A small grey line under the hint: a range, a default. */
+    meta?: string;
+    /** A short warning badge beside the label, for a setting that widens what an agent may do. */
+    risk?: string;
+    /** The setting is read when the plugin starts: a badge saying so, with a `?` explaining why; `touched` picks it out while an edit of it is waiting to be saved. */
+    restart?: {
+        badge: string;
+        why: string;
+        touched?: boolean;
+    };
+    /** Extra controls beside the label (the "changed by the agent" mark with its adopt / revoke buttons). */
+    mark?: ReactNode;
+    disabled?: boolean;
+    labels: RowLabels;
+    onReset?: () => void;
+    /** Control placement: beside the text (default) or on its own line. */
+    wide?: boolean;
+    inline?: boolean;
+    children: ReactNode;
+}
+/** One setting: label, one-line hint, an optional `?`, the "overridden" badge with its reset, and the control. */
+export declare function Row(props: RowProps): import("react").JSX.Element;
+/** A closed-by-default fold inside a group, for the items few people need. */
+export declare function Fold(props: {
+    id: string;
+    title: string;
+    hint?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A small heading inside a group, for sets of rows that belong together. */
+export declare function SubHead(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * One group of the card, an accordion item. `<details>` keeps every control in the document while the group is
+ * closed (so a server-rendered check still sees them) and gives keyboard and screen-reader behavior for free.
+ */
+export declare function Group(props: {
+    id: string;
+    title: string;
+    summary?: string;
+    badges?: ReactNode;
+    defaultOpen?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface SelectOption {
+    value: string;
+    label: string;
+}
+/**
+ * A native select. A stored value that is not among the options (a channel the list does not know, an older
+ * enum value) is shown as its own entry instead of being silently replaced by the first option.
+ */
+export declare function Select(props: {
+    id?: string;
+    value: string;
+    options: readonly SelectOption[];
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    muted?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+}): import("react").JSX.Element;
+/** A single-line text input; `muted` greys the value while it is only the inherited default. */
+export declare function TextInput(props: {
+    id?: string;
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    muted?: boolean;
+    invalid?: boolean;
+    list?: string;
+    numeric?: boolean;
+    ariaLabel?: string;
+    code?: boolean;
+    small?: boolean;
+    autoFocus?: boolean;
+    onBlur?: () => void;
+}): import("react").JSX.Element;
+/** A text input followed by a fixed unit. */
+export declare function UnitInput(props: {
+    id?: string;
+    value: string;
+    unit: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    muted?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+}): import("react").JSX.Element;
+/** The Host's switch, named by its row. */
+export declare function Toggle(props: {
+    label: string;
+    checked: boolean;
+    onChange: (next: boolean) => void;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+/** A list of short strings as removable chips with an add box (Enter or comma adds; Backspace on an empty box removes the last). */
+export declare function Chips(props: {
+    id?: string;
+    values: readonly string[];
+    onChange: (values: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Why a new entry is refused, or undefined. */
+    check?: (value: string, existing: readonly string[]) => string | undefined;
+    removeLabel: string;
+    addLabel: string;
+}): import("react").JSX.Element;
+/** A dialog on the Host's modal: a title, a scrolling body, and a footer of actions. */
+export declare function Dialog(props: {
+    open: boolean;
+    title: string;
+    closeLabel: string;
+    description?: string;
+    onClose: () => void;
+    footer?: ReactNode;
+    wide?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Primary and secondary buttons at the card's size. */
+export declare function Btn(props: {
+    children: ReactNode;
+    onClick?: () => void;
+    primary?: boolean;
+    disabled?: boolean;
+    danger?: boolean;
+    title?: string;
+    data?: string;
+    ariaLabel?: string;
+}): import("react").JSX.Element;
+/** A list row: a title with badges, a meta line, and actions on the right. */
+export declare function Item(props: {
+    title: ReactNode;
+    badges?: ReactNode;
+    meta?: ReactNode;
+    actions?: ReactNode;
+    data?: string;
+}): import("react").JSX.Element;
+/** A write-only secret input: it never shows a stored value, only whether one is configured. */
+export declare function SecretInput(props: {
+    id: string;
+    value: string;
+    onChange: (value: string) => void;
+    status: string;
+    configured: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}): import("react").JSX.Element;

package/lib/types/client/validators.d.ts

@@ -48,3 +48,9 @@ export declare function evidenceIssues(ev: Json): Issue[];
 export declare function sourcesIssues(sources: Json): Issue[];
 /** Rubric override ids in a settings object that name no built-in rubric (the server ignores them). */
 export declare function unknownRubricIds(rubrics: unknown): string[];
+/**
+ * Problems of the CLI adapter settings, from the server's own functions: `cliAdapters` entries the server would ignore
+ * (read-only guard, bad argv, secrets in env) and `platformBackends` that name an unknown platform or a backend that
+ * cannot serve it.
+ */
+export declare function cliIssues(platformBackends: unknown, cliAdapters: unknown): Issue[];

package/lib/types/config-fillers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removal of the empty containers the Host's schema parser fills in (see the comment on `withoutFillers`). Pure and free of
+ * imports: the server's config resolution and the settings card's validation (client bundle) use the same functions.
+ * @module web-search-pro/config-fillers
+ */
+export declare function withoutFillers<T>(value: T, keys: readonly string[]): T;
+export declare function normalizeJudge<T>(judge: T): T;
+export declare function normalizeRubrics<T>(rubrics: T): T;
+export declare function normalizeCoverage<T>(coverage: T): T;

package/lib/types/config-groups.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The groups the configuration is laid out in, and the order of its fields. One definition serves four readers: the order of
+ * the keys of the `Config` schema (what the Host's generic configuration view and `--dump-config` print), the sections of the
+ * settings card's text view, the group a field belongs to in the card's tests, and the docs. A test pins the schema to this
+ * list, so a new field cannot be added without choosing its group.
+ *
+ * The groups follow the settings page, most used first: common, search order, sources and keys, custom CLI, reading and
+ * evidence, platforms and runtime, advanced and diagnostics. Only top-level `Config` keys are listed; a key that is an object
+ * (`sources`, `evidence`, `provider`, `keyedSources`, `playwright`) takes all of its nested options with it.
+ *
+ * Pure and free of imports: the client bundle includes this file.
+ * @module web-search-pro/config-groups
+ */
+export declare const CONFIG_GROUP_IDS: readonly ["common", "order", "sources", "cli", "evidence", "runtime", "advanced"];
+export type ConfigGroupId = typeof CONFIG_GROUP_IDS[number];
+/** Top-level `Config` keys by group, in display order. */
+export declare const CONFIG_GROUPS: Readonly<Record<ConfigGroupId, readonly string[]>>;
+/** Titles of the groups, as the text view prints them (the card's own group titles live in its dictionary). */
+export declare const CONFIG_GROUP_TITLES: Readonly<Record<'en' | 'zh', Readonly<Record<ConfigGroupId, string>>>>;
+/** Every top-level key in display order. */
+export declare const CONFIG_FIELD_ORDER: readonly string[];
+/** The group of a top-level key, or of a dotted field (`sources.priority`, `evidence.judge.mode`) by its first segment. */
+export declare function groupOf(field: string): ConfigGroupId | undefined;