@promptbook/cli 0.114.0-3 → 0.114.0-30

package/apps/agents-server/src/utils/cronExpression/normalizeCronExpression.ts

@@ -0,0 +1,34 @@
+import { spaceTrim } from 'spacetrim';
+import { ParseError } from '../../../../../src/errors/ParseError';
+import { normalizeCronExpressionWhitespace } from './normalizeCronExpressionWhitespace';
+import { parseCronExpression } from './parseCronExpression';
+import { resolveNextCronRunFromParsedExpression } from './resolveNextCronRun';
+
+/**
+ * Normalizes and validates one cron expression.
+ *
+ * An expression which parses but never matches a real date, such as `0 0 30 2 *`, is rejected here
+ * instead of silently becoming a schedule that never runs.
+ *
+ * @param expression - Raw cron expression.
+ * @returns Whitespace-normalized expression.
+ *
+ * @private function of `cronExpression`
+ */
+export function normalizeCronExpression(expression: string): string {
+    const normalizedExpression = normalizeCronExpressionWhitespace(expression);
+
+    if (normalizedExpression === '') {
+        throw new ParseError(
+            spaceTrim(`
+                Cron expression is empty.
+
+                **Use exactly five fields:** minute hour day-of-month month day-of-week.
+            `),
+        );
+    }
+
+    resolveNextCronRunFromParsedExpression(parseCronExpression(normalizedExpression), new Date());
+
+    return normalizedExpression;
+}

package/apps/agents-server/src/utils/cronExpression/normalizeCronExpressionWhitespace.ts

@@ -0,0 +1,11 @@
+/**
+ * Collapses cron whitespace without changing any field value.
+ *
+ * @param expression - Raw cron expression.
+ * @returns Whitespace-normalized expression, which is empty when the input holds no field at all.
+ *
+ * @private function of `cronExpression`
+ */
+export function normalizeCronExpressionWhitespace(expression: string): string {
+    return expression.trim().replace(/\s+/gu, ' ');
+}

package/apps/agents-server/src/utils/cronExpression/parseCronExpression.ts

@@ -0,0 +1,41 @@
+import { spaceTrim } from 'spacetrim';
+import { ParseError } from '../../../../../src/errors/ParseError';
+import { CRON_EXPRESSION_FIELD_COUNT, type ParsedCronExpression } from './CronExpression';
+import { normalizeCronExpressionWhitespace } from './normalizeCronExpressionWhitespace';
+import { parseCronExpressionField } from './parseCronExpressionField';
+
+/**
+ * Parses one five-field cron expression into numeric field sets.
+ *
+ * @param expression - Raw cron expression, for example `15 9-17 * * 1-5`.
+ * @returns Parsed cron expression.
+ *
+ * @private function of `cronExpression`
+ */
+export function parseCronExpression(expression: string): ParsedCronExpression {
+    const normalizedExpression = normalizeCronExpressionWhitespace(expression);
+    const fields = normalizedExpression.split(' ');
+
+    if (fields.length !== CRON_EXPRESSION_FIELD_COUNT) {
+        throw new ParseError(
+            spaceTrim(`
+                Cron expression \`${normalizedExpression}\` is invalid.
+
+                **Use exactly five fields:** minute hour day-of-month month day-of-week.
+            `),
+        );
+    }
+
+    return {
+        minute: parseCronExpressionField(fields[0]!, { name: 'minute', minimum: 0, maximum: 59 }),
+        hour: parseCronExpressionField(fields[1]!, { name: 'hour', minimum: 0, maximum: 23 }),
+        dayOfMonth: parseCronExpressionField(fields[2]!, { name: 'day-of-month', minimum: 1, maximum: 31 }),
+        month: parseCronExpressionField(fields[3]!, { name: 'month', minimum: 1, maximum: 12 }),
+        dayOfWeek: parseCronExpressionField(fields[4]!, {
+            name: 'day-of-week',
+            minimum: 0,
+            maximum: 7,
+            isSevenAllowedForSunday: true,
+        }),
+    };
+}

package/apps/agents-server/src/utils/cronExpression/parseCronExpressionField.ts

@@ -0,0 +1,140 @@
+import type { CronExpressionField, CronExpressionFieldOptions } from './CronExpression';
+import { throwInvalidCronExpressionField } from './throwInvalidCronExpressionField';
+
+/**
+ * Parses one cron field with comma lists, ranges, and step values.
+ *
+ * @param field - Raw field value.
+ * @param options - Numeric bounds and label of the field.
+ * @returns Parsed field values.
+ *
+ * @private function of `cronExpression`
+ */
+export function parseCronExpressionField(field: string, options: CronExpressionFieldOptions): CronExpressionField {
+    const values = new Set<number>();
+    const isWildcard = field === '*';
+
+    for (const part of field.split(',')) {
+        if (!part) {
+            throwInvalidCronExpressionField(field, options.name);
+        }
+
+        addCronExpressionFieldPart(values, part, options);
+    }
+
+    if (values.size === 0) {
+        throwInvalidCronExpressionField(field, options.name);
+    }
+
+    return { values, isWildcard };
+}
+
+/**
+ * Adds the values represented by one comma-separated cron field part.
+ *
+ * @param values - Mutable field value set.
+ * @param part - Field part, for example a wildcard, `1-5`, or a stepped wildcard.
+ * @param options - Numeric bounds and label of the field.
+ *
+ * @private function of `parseCronExpressionField`
+ */
+function addCronExpressionFieldPart(values: Set<number>, part: string, options: CronExpressionFieldOptions): void {
+    const stepSplit = part.split('/');
+    if (stepSplit.length > 2) {
+        throwInvalidCronExpressionField(part, options.name);
+    }
+
+    const rangePart = stepSplit[0]!;
+    const step = stepSplit[1] === undefined ? 1 : parseCronExpressionNumber(stepSplit[1], options.name);
+    if (step <= 0) {
+        throwInvalidCronExpressionField(part, options.name);
+    }
+
+    const { start, end } = parseCronExpressionRange(rangePart, options);
+    for (let value = start; value <= end; value += step) {
+        values.add(normalizeCronExpressionFieldValue(value, options));
+    }
+}
+
+/**
+ * Parses the range portion of one cron field part.
+ *
+ * @param rangePart - Range part before the optional `/step`.
+ * @param options - Numeric bounds and label of the field.
+ * @returns Start and end range values.
+ *
+ * @private function of `parseCronExpressionField`
+ */
+function parseCronExpressionRange(
+    rangePart: string,
+    options: CronExpressionFieldOptions,
+): { readonly start: number; readonly end: number } {
+    if (rangePart === '*') {
+        return { start: options.minimum, end: options.maximum };
+    }
+
+    const rangeSplit = rangePart.split('-');
+    if (rangeSplit.length > 2 || rangeSplit.some((value) => value === '')) {
+        throwInvalidCronExpressionField(rangePart, options.name);
+    }
+
+    const start = parseCronExpressionNumber(rangeSplit[0]!, options.name);
+    const end = rangeSplit[1] === undefined ? start : parseCronExpressionNumber(rangeSplit[1], options.name);
+
+    if (start > end) {
+        throwInvalidCronExpressionField(rangePart, options.name);
+    }
+
+    assertCronExpressionFieldValueInRange(start, options);
+    assertCronExpressionFieldValueInRange(end, options);
+
+    return { start, end };
+}
+
+/**
+ * Parses one positive cron integer token.
+ *
+ * @param value - Raw token.
+ * @param fieldName - Field name used in validation errors.
+ * @returns Parsed integer.
+ *
+ * @private function of `parseCronExpressionField`
+ */
+function parseCronExpressionNumber(value: string, fieldName: string): number {
+    if (!/^\d+$/u.test(value)) {
+        throwInvalidCronExpressionField(value, fieldName);
+    }
+
+    return Number.parseInt(value, 10);
+}
+
+/**
+ * Asserts that one parsed cron value is inside the field bounds.
+ *
+ * @param value - Parsed value.
+ * @param options - Numeric bounds and label of the field.
+ *
+ * @private function of `parseCronExpressionField`
+ */
+function assertCronExpressionFieldValueInRange(value: number, options: CronExpressionFieldOptions): void {
+    if (value < options.minimum || value > options.maximum) {
+        throwInvalidCronExpressionField(String(value), options.name);
+    }
+}
+
+/**
+ * Normalizes Sunday from `7` to `0` in the day-of-week field.
+ *
+ * @param value - Parsed field value.
+ * @param options - Numeric bounds and label of the field.
+ * @returns Normalized value.
+ *
+ * @private function of `parseCronExpressionField`
+ */
+function normalizeCronExpressionFieldValue(value: number, options: CronExpressionFieldOptions): number {
+    if (options.isSevenAllowedForSunday && value === 7) {
+        return 0;
+    }
+
+    return value;
+}

package/apps/agents-server/src/utils/cronExpression/resolveNextCronRun.ts

@@ -0,0 +1,100 @@
+import { spaceTrim } from 'spacetrim';
+import { ParseError } from '../../../../../src/errors/ParseError';
+import type { ParsedCronExpression } from './CronExpression';
+import { parseCronExpression } from './parseCronExpression';
+
+/**
+ * Maximum number of minutes scanned while finding the next cron run.
+ *
+ * Five years keeps leap-day schedules valid while still rejecting impossible expressions.
+ *
+ * @private constant of `cronExpression`
+ */
+const CRON_EXPRESSION_LOOKAHEAD_MINUTES = 366 * 24 * 60 * 5;
+
+/**
+ * Finds the next local server time matching one cron expression.
+ *
+ * @param cronExpression - Cron expression, validated on the fly.
+ * @param afterDate - Date after which the next run must happen.
+ * @returns Next matching local server time.
+ *
+ * @private function of `cronExpression`
+ */
+export function resolveNextCronRun(cronExpression: string, afterDate = new Date()): Date {
+    return resolveNextCronRunFromParsedExpression(parseCronExpression(cronExpression), afterDate);
+}
+
+/**
+ * Finds the next local server time matching one already parsed cron expression.
+ *
+ * @param parsedCronExpression - Parsed cron expression.
+ * @param afterDate - Date after which the next run must happen.
+ * @returns Next matching local server time.
+ *
+ * @private function of `cronExpression`
+ */
+export function resolveNextCronRunFromParsedExpression(
+    parsedCronExpression: ParsedCronExpression,
+    afterDate: Date,
+): Date {
+    const cursor = new Date(afterDate.getTime());
+    cursor.setSeconds(0, 0);
+    cursor.setMinutes(cursor.getMinutes() + 1);
+
+    for (let index = 0; index < CRON_EXPRESSION_LOOKAHEAD_MINUTES; index++) {
+        if (isCronExpressionDateMatched(parsedCronExpression, cursor)) {
+            return new Date(cursor.getTime());
+        }
+
+        cursor.setMinutes(cursor.getMinutes() + 1);
+    }
+
+    throw new ParseError(
+        spaceTrim(`
+            Cron expression cannot be scheduled.
+
+            **Use a cron expression that matches at least one valid date.**
+        `),
+    );
+}
+
+/**
+ * Tests whether one date matches a parsed cron expression.
+ *
+ * @param parsedCronExpression - Parsed cron expression.
+ * @param date - Candidate local server date.
+ * @returns `true` when the date matches.
+ *
+ * @private function of `resolveNextCronRun`
+ */
+function isCronExpressionDateMatched(parsedCronExpression: ParsedCronExpression, date: Date): boolean {
+    if (!parsedCronExpression.minute.values.has(date.getMinutes())) {
+        return false;
+    }
+
+    if (!parsedCronExpression.hour.values.has(date.getHours())) {
+        return false;
+    }
+
+    if (!parsedCronExpression.month.values.has(date.getMonth() + 1)) {
+        return false;
+    }
+
+    const isDayOfMonthMatched = parsedCronExpression.dayOfMonth.values.has(date.getDate());
+    const isDayOfWeekMatched = parsedCronExpression.dayOfWeek.values.has(date.getDay());
+
+    if (parsedCronExpression.dayOfMonth.isWildcard && parsedCronExpression.dayOfWeek.isWildcard) {
+        return true;
+    }
+
+    if (parsedCronExpression.dayOfMonth.isWildcard) {
+        return isDayOfWeekMatched;
+    }
+
+    if (parsedCronExpression.dayOfWeek.isWildcard) {
+        return isDayOfMonthMatched;
+    }
+
+    return isDayOfMonthMatched || isDayOfWeekMatched;
+}

package/apps/agents-server/src/utils/cronExpression/throwInvalidCronExpressionField.ts

@@ -0,0 +1,20 @@
+import { spaceTrim } from 'spacetrim';
+import { ParseError } from '../../../../../src/errors/ParseError';
+
+/**
+ * Throws a branded validation error for one invalid cron field value.
+ *
+ * @param value - Invalid field value.
+ * @param fieldName - Field name shown in the error message.
+ *
+ * @private function of `cronExpression`
+ */
+export function throwInvalidCronExpressionField(value: string, fieldName: string): never {
+    throw new ParseError(
+        spaceTrim(`
+            Cron field \`${fieldName}\` contains invalid value \`${value}\`.
+
+            **Use numbers, \`*\`, comma lists, ranges, and step values only.**
+        `),
+    );
+}

package/apps/agents-server/src/utils/cronExpression.ts

@@ -0,0 +1,10 @@
+export { CRON_EXPRESSION_FIELD_COUNT } from './cronExpression/CronExpression';
+export { normalizeCronExpression } from './cronExpression/normalizeCronExpression';
+export { normalizeCronExpressionWhitespace } from './cronExpression/normalizeCronExpressionWhitespace';
+export { parseCronExpression } from './cronExpression/parseCronExpression';
+export { resolveNextCronRun, resolveNextCronRunFromParsedExpression } from './cronExpression/resolveNextCronRun';
+export type {
+    CronExpressionField,
+    CronExpressionFieldOptions,
+    ParsedCronExpression,
+} from './cronExpression/CronExpression';

package/apps/agents-server/src/utils/currentServerRegistryContext.ts

@@ -1,5 +1,6 @@
 import { headers } from 'next/headers';
-import { listRegisteredServersUsingServiceRole, type ServerRecord } from './serverRegistry';
+import type { ServerRecord } from './serverRegistry';
+import { listRegisteredServersUsingServiceRole } from './serverRegistryNode';
 import { resolveServerSelection } from './serverSelection';
 
 /**

package/apps/agents-server/src/utils/customDomainRouting.ts

@@ -12,12 +12,15 @@ import { NotFoundError } from '../../../../src/errors/NotFoundError';
 import { ParseError } from '../../../../src/errors/ParseError';
 import { spaceTrim } from '../../../../src/utils/organization/spaceTrim';
 import { normalizeDomainForMatching } from '../../../../src/utils/validators/url/normalizeDomainForMatching';
-import type { FederatedAgentImportConfiguration } from '../constants/federatedAgentImport';
+import {
+    DEFAULT_FEDERATED_AGENT_IMPORT_CONFIGURATION,
+    FEDERATED_AGENT_IMPORT_MAX_ATTEMPTS,
+    FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY,
+    FEDERATED_SERVERS_METADATA_KEY,
+    type FederatedAgentImportConfiguration,
+} from '../constants/federatedAgentImport';
 import { isSameAgentPermanentId } from './agentIdentifier';
 import { createServerAgentReferenceResolver } from './agentReferenceResolver/createServerAgentReferenceResolver';
-import { loadFederatedAgentImportConfiguration } from './federatedAgentImportConfiguration';
-import { getFederatedServers } from './getFederatedServers';
-import { getWellKnownAgentUrl } from './getWellKnownAgentUrl';
 import {
     createLocalAgentUrl,
     normalizeLocalAgentUrlReferences,
@@ -26,6 +29,8 @@ import {
 } from './localAgentRouteReferences';
 import { createMissingImportedAgentFallback } from './createMissingImportedAgentFallback';
 import { resolveInheritedAgentSource, type AgentSourceImporter } from './resolveInheritedAgentSource';
+import { createWellKnownAgentUrl } from './createWellKnownAgentUrl';
+import { parseFederatedServers } from './parseFederatedServers';
 import { createServerPublicUrl, type ServerRecord } from './serverRegistry';
 
 /**
@@ -38,6 +43,16 @@ const HTTP_PROTOCOL_PREFIX = 'http://';
  */
 const HTTPS_PROTOCOL_PREFIX = 'https://';
 
+/**
+ * Metadata values needed to resolve inherited custom-domain agent sources in Edge middleware.
+ *
+ * @private constant of custom-domain routing
+ */
+const CUSTOM_DOMAIN_FEDERATED_METADATA_KEYS = [
+    FEDERATED_SERVERS_METADATA_KEY,
+    FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY,
+] as const;
+
 /**
  * Candidate values used when searching one custom host in `agentProfile`.
  */
@@ -134,6 +149,35 @@ type CustomDomainAgentRow = {
  */
 type ResolvedCustomDomainMetadata = Pick<AgentBasicInformation, 'links' | 'meta'>;
 
+/**
+ * Metadata row shape needed while resolving a custom-domain agent in Edge middleware.
+ *
+ * @private type of custom-domain routing
+ */
+type CustomDomainMetadataRow = {
+    readonly key: unknown;
+    readonly value: unknown;
+};
+
+/**
+ * Dedicated server-limit row shape needed while resolving a custom-domain agent in Edge middleware.
+ *
+ * @private type of custom-domain routing
+ */
+type CustomDomainServerLimitRow = {
+    readonly value: unknown;
+};
+
+/**
+ * Federation dependencies scoped to the server currently considered for a custom-domain match.
+ *
+ * @private type of custom-domain routing
+ */
+type CustomDomainFederatedDependencies = {
+    readonly federatedAgentImportConfiguration: FederatedAgentImportConfiguration;
+    readonly federatedServers: ReadonlyArray<string>;
+};
+
 /**
  * Creates a minimal local collection used only for compact-reference initialization.
  *
@@ -426,12 +470,6 @@ export async function resolveCustomDomainAgent(
         return null;
     }
 
-    const [federatedServers, adamAgentUrl, federatedAgentImportConfiguration] = await Promise.all([
-        getFederatedServers(),
-        getWellKnownAgentUrl('ADAM'),
-        loadFederatedAgentImportConfiguration(),
-    ]);
-
     for (const server of servers) {
         try {
             const tableName = `${server.tablePrefix}Agent`;
@@ -455,6 +493,9 @@ export async function resolveCustomDomainAgent(
             }
 
             const localServerUrl = createServerPublicUrl(server.domain).href;
+            const { federatedServers, federatedAgentImportConfiguration } =
+                await loadCustomDomainFederatedDependencies(supabase, server);
+            const adamAgentUrl = createWellKnownAgentUrl(localServerUrl, 'ADAM');
             const agentCollection = createResolverAgentCollection(
                 resolverReferenceAgents as Array<CustomDomainAgentRow>,
             );
@@ -502,6 +543,98 @@ export async function resolveCustomDomainAgent(
     return null;
 }
 
+/**
+ * Loads federation settings for the server currently checked for a custom-domain agent.
+ *
+ * Middleware already owns an Edge-compatible Supabase client. Reading the needed rows through
+ * that client keeps custom-domain routing usable in the Edge runtime and avoids request-scoped
+ * Node database helpers, which can load the standalone SQLite backend.
+ *
+ * @param supabase - Edge-compatible Supabase client supplied by middleware.
+ * @param server - Candidate server whose inherited agent source is being resolved.
+ * @returns Federation dependencies, falling back to safe defaults when configuration is unavailable.
+ *
+ * @private function of custom-domain routing
+ */
+async function loadCustomDomainFederatedDependencies(
+    supabase: SupabaseClient,
+    server: ServerRecord,
+): Promise<CustomDomainFederatedDependencies> {
+    try {
+        const metadataTableName = `${server.tablePrefix}Metadata`;
+        const serverLimitTableName = `${server.tablePrefix}ServerLimit`;
+        const [metadataResponse, serverLimitResponse] = await Promise.all([
+            supabase.from(metadataTableName).select('key, value').in('key', CUSTOM_DOMAIN_FEDERATED_METADATA_KEYS),
+            supabase
+                .from(serverLimitTableName)
+                .select('value')
+                .eq('key', FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY)
+                .maybeSingle(),
+        ]);
+        const metadataRows = metadataResponse.error
+            ? []
+            : ((Array.isArray(metadataResponse.data) ? metadataResponse.data : []) as Array<CustomDomainMetadataRow>);
+        const serverLimitRow = serverLimitResponse.error
+            ? null
+            : (serverLimitResponse.data as CustomDomainServerLimitRow | null);
+        const federatedServersValue = readCustomDomainMetadataValue(metadataRows, FEDERATED_SERVERS_METADATA_KEY);
+        const legacyRetryDelayValue = readCustomDomainMetadataValue(
+            metadataRows,
+            FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY,
+        );
+
+        return {
+            federatedServers: parseFederatedServers(federatedServersValue),
+            federatedAgentImportConfiguration: {
+                maxAttempts: FEDERATED_AGENT_IMPORT_MAX_ATTEMPTS,
+                retryDelayMs: normalizeFederatedAgentImportRetryDelayMs(
+                    serverLimitRow?.value ?? legacyRetryDelayValue,
+                ),
+            },
+        };
+    } catch {
+        return {
+            federatedServers: [],
+            federatedAgentImportConfiguration: DEFAULT_FEDERATED_AGENT_IMPORT_CONFIGURATION,
+        };
+    }
+}
+
+/**
+ * Reads one named metadata value from a custom-domain routing query result.
+ *
+ * @param rows - Raw metadata rows loaded for the candidate server.
+ * @param key - Metadata key to read.
+ * @returns Stored string value, or `undefined` when unavailable.
+ *
+ * @private function of custom-domain routing
+ */
+function readCustomDomainMetadataValue(
+    rows: ReadonlyArray<CustomDomainMetadataRow>,
+    key: string,
+): string | undefined {
+    const row = rows.find((candidate) => candidate.key === key);
+    return typeof row?.value === 'string' ? row.value : undefined;
+}
+
+/**
+ * Normalizes the one federation retry delay used by Edge custom-domain routing.
+ *
+ * @param value - Dedicated limit or legacy metadata value.
+ * @returns A finite non-negative retry delay, or the shared default.
+ *
+ * @private function of custom-domain routing
+ */
+function normalizeFederatedAgentImportRetryDelayMs(value: unknown): number {
+    const parsedValue = Number(value);
+
+    if (!Number.isFinite(parsedValue) || parsedValue < 0) {
+        return DEFAULT_FEDERATED_AGENT_IMPORT_CONFIGURATION.retryDelayMs;
+    }
+
+    return Math.floor(parsedValue);
+}
+
 /**
  * Returns unique, non-empty values while keeping original order.
  *

package/apps/agents-server/src/utils/dnsRecords/DnsRecordInstruction.ts

@@ -31,3 +31,23 @@ export type DnsRecordInstruction = {
      */
     readonly note: string | null;
 };
+
+/**
+ * DNS records which belong together and share one all-or-one configuration rule.
+ *
+ * One DNS manual can show more groups at once, for example the server domain records, the generated project domain
+ * records, and the email records of one Agents Server.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export type DnsRecordGroup = {
+    /**
+     * Whether every record of the group or just one of its alternatives must be configured.
+     */
+    readonly recordSelection: DnsRecordSelection;
+
+    /**
+     * DNS records of the group.
+     */
+    readonly records: ReadonlyArray<DnsRecordInstruction>;
+};

package/apps/agents-server/src/utils/dnsRecords/DnsRecordsSection.ts

@@ -0,0 +1,77 @@
+import type { ReactNode } from 'react';
+import type { DnsRecordGroup } from './DnsRecordInstruction';
+
+/**
+ * One alternative setup of a DNS record section.
+ *
+ * A section with a single variant has nothing to choose from, a section with more variants lets the administrator
+ * pick exactly one of them, for example the wildcard or the single-project setup of generated project domains.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export type DnsRecordsSectionVariant = DnsRecordGroup & {
+    /**
+     * Stable identifier of the variant, unique within its section.
+     */
+    readonly id: string;
+
+    /**
+     * Label of the variant button.
+     */
+    readonly label: string;
+
+    /**
+     * Explanation of what the selected variant covers.
+     */
+    readonly description?: ReactNode;
+};
+
+/**
+ * One part of the DNS setup of an Agents Server, for example its domain, its projects, or its email.
+ *
+ * Every page shows the same sections in the same shared component, just filtered down to the sections which are
+ * relevant for that page.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export type DnsRecordsSection = {
+    /**
+     * Stable identifier of the section, unique within one DNS manual.
+     */
+    readonly id: string;
+
+    /**
+     * Human-readable name of the configured part, for example `Email`.
+     */
+    readonly title: string;
+
+    /**
+     * Explanation of what the section configures.
+     */
+    readonly description?: ReactNode;
+
+    /**
+     * Label shown above the variant buttons.
+     */
+    readonly variantsLabel?: string;
+
+    /**
+     * Alternative setups of the section, at least one of them.
+     */
+    readonly variants: ReadonlyArray<DnsRecordsSectionVariant>;
+
+    /**
+     * Current DNS verification state of the section, when it is known.
+     */
+    readonly statusSummary?: string | null;
+
+    /**
+     * Addresses currently returned by public DNS, when verification is available.
+     */
+    readonly resolvedAddresses?: ReadonlyArray<string>;
+
+    /**
+     * Whether the section currently needs attention.
+     */
+    readonly isDnsIssue?: boolean;
+};