@datalayer/agent-runtimes 1.3.83 → 1.3.85

package/lib/loop/apps/customComponents.js

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Components a developer writes (LOOP P-17): an A2UI component of one
+ * application only, declared in its Appspec (`interface.custom_components`)
+ * with its name, its properties as a JSON Schema, what it shows and sends,
+ * and the address of the built ES module that draws it.
+ *
+ * Reviewed like any component of the catalog — what agentspecs refuses is
+ * refused here in the same sentences — and listed beside the catalog's for
+ * that application alone (`appComponents`): the catalog grows for it, it
+ * does not open. How it is drawn, in a sandboxed frame of no origin, is
+ * `components/a2ui/custom`.
+ *
+ * @module loop/apps/customComponents
+ */
+import { getComponent } from '../../specs/uiPlugins';
+/** Its name: a word starting with a capital letter, as the catalog's are named. */
+export const CUSTOM_COMPONENT_NAME = /^[A-Z][A-Za-z0-9]{0,63}$/;
+/** What one of its properties may be typed: what the renderer tells apart. */
+export const CUSTOM_PROPERTY_TYPES = [
+    'string',
+    'integer',
+    'number',
+    'boolean',
+    'array',
+    'object',
+];
+/** What every component of a surface already has, and a custom one cannot declare. */
+export const CUSTOM_RESERVED_NAMES = [
+    'id',
+    'component',
+    'action',
+    'weight',
+    'visible_when',
+    'children',
+    'child',
+];
+/**
+ * Where its module is loaded from: an address served over HTTPS, or this
+ * machine while it is written. A file of the application's folder waits for
+ * its packaging (P-29).
+ */
+export const CUSTOM_SOURCE = /^(?:https:\/\/[A-Za-z0-9.-]+(?::\d+)?|http:\/\/(?:localhost|127\.0\.0\.1)(?::\d+)?)\/\S*$/;
+/** A Subresource Integrity hash: the module as it was reviewed. */
+export const INTEGRITY = /^sha(?:256|384|512)-[A-Za-z0-9+/]+={0,2}$/;
+const PROPERTY_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isBound = (value) => isRecord(value) && 'path' in value;
+const quoted = (name) => `'${name}'`;
+/** Why a value is not one a property takes, or null. */
+function valueRefused(name, field, value) {
+    if (Array.isArray(field.enum)) {
+        return field.enum.includes(value)
+            ? null
+            : `${quoted(name)} is one of ${field.enum.map(each => quoted(String(each))).join(', ')}`;
+    }
+    const kind = String(field.type);
+    const takes = {
+        string: v => typeof v === 'string',
+        integer: v => typeof v === 'number' && Number.isInteger(v),
+        number: v => typeof v === 'number',
+        boolean: v => typeof v === 'boolean',
+        array: v => Array.isArray(v),
+        object: isRecord,
+    };
+    if (typeof value === 'boolean' && kind !== 'boolean') {
+        return `${quoted(name)} is ${kind}, not true or false`;
+    }
+    return takes[kind]?.(value) ? null : `${quoted(name)} is ${kind}`;
+}
+/** Its properties, as its schema declares them. */
+const fieldsOf = (component) => (isRecord(component.props.properties)
+    ? component.props.properties
+    : {});
+/**
+ * What its schema refuses of the properties given, in the words agentspecs
+ * says them: one it does not have, a value of another type, one it needs.
+ * `bound` are given elsewhere — bound to what the application publishes.
+ */
+export function customPropsRefused(component, props, bound = []) {
+    const fields = fieldsOf(component);
+    const problems = Object.keys(props)
+        .filter(name => !(name in fields))
+        .map(name => `it has no property ${quoted(name)}`);
+    for (const [name, value] of Object.entries(props)) {
+        if (name in fields && !isBound(value)) {
+            const refused = valueRefused(name, fields[name], value);
+            if (refused) {
+                problems.push(refused);
+            }
+        }
+    }
+    const required = Array.isArray(component.props.required)
+        ? component.props.required
+        : [];
+    for (const name of required) {
+        if (!(name in props) && !bound.includes(name)) {
+            problems.push(`it needs ${quoted(name)}`);
+        }
+    }
+    return problems;
+}
+/** What stops one component its developer wrote from being reviewed, in sentences. */
+export function customComponentProblems(component) {
+    const said = `The component ${component.name || '(unnamed)'}`;
+    const problems = [];
+    if (!CUSTOM_COMPONENT_NAME.test(component.name)) {
+        problems.push(`Cannot use “${component.name}” as a component's name: a word starting with a capital letter, as Gauge.`);
+    }
+    else if (getComponent(component.name)) {
+        problems.push(`${said} is a component of the catalog: name yours otherwise.`);
+    }
+    if (!component.description.trim()) {
+        problems.push(`${said} says what it is for, under \`description\`.`);
+    }
+    if (!/^[a-z][a-z0-9+.-]*:/.test(component.source)) {
+        problems.push(`${said}'s module “${component.source}” is a file of the application's folder: it is drawn once the application is packaged with it (LOOP P-29); give the address of a built ES module.`);
+    }
+    else if (!CUSTOM_SOURCE.test(component.source)) {
+        problems.push(`${said}'s module “${component.source}” is loaded over \`https://\`, or from \`http://localhost\` while it is written.`);
+    }
+    if (component.integrity && !INTEGRITY.test(component.integrity)) {
+        problems.push(`${said}'s integrity “${component.integrity}” is no Subresource Integrity hash: \`sha384-\` and the hash in base64.`);
+    }
+    if (component.height < 40 || component.height > 2000) {
+        problems.push(`${said} is between 40 and 2000 pixels high.`);
+    }
+    const schema = component.props;
+    if (schema.type !== 'object' || !isRecord(schema.properties)) {
+        problems.push(`${said}'s props are the JSON Schema of an object, with its \`properties\`.`);
+        return problems;
+    }
+    const fields = fieldsOf(component);
+    for (const [name, field] of Object.entries(fields)) {
+        if (!PROPERTY_NAME.test(name) ||
+            CUSTOM_RESERVED_NAMES.includes(name)) {
+            problems.push(`${said} cannot have a property named ${quoted(name)}.`);
+            continue;
+        }
+        if (!isRecord(field)) {
+            problems.push(`${said}'s property ${quoted(name)} is not a schema.`);
+            continue;
+        }
+        if ('enum' in field) {
+            const values = field.enum;
+            if (!Array.isArray(values) ||
+                values.length === 0 ||
+                !values.every(value => typeof value === 'string')) {
+                problems.push(`${said}'s property ${quoted(name)} is an \`enum\` of words, one at least.`);
+            }
+        }
+        else if (!CUSTOM_PROPERTY_TYPES.includes(field.type)) {
+            problems.push(`${said}'s property ${quoted(name)} is typed ${quoted(String(field.type))}: one of ${CUSTOM_PROPERTY_TYPES.join(', ')}, or an \`enum\`.`);
+            continue;
+        }
+        if ('default' in field) {
+            const refused = valueRefused(name, field, field.default);
+            if (refused) {
+                problems.push(`${said}'s default for ${refused}.`);
+            }
+        }
+    }
+    const required = Array.isArray(schema.required)
+        ? schema.required
+        : [];
+    const missing = required.filter(name => !(name in fields));
+    if (missing.length > 0) {
+        problems.push(`${said} requires ${missing.map(quoted).join(', ')}, which its props do not have.`);
+    }
+    for (const name of [...component.shows, ...component.sends]) {
+        if (!PROPERTY_NAME.test(name) ||
+            CUSTOM_RESERVED_NAMES.includes(name)) {
+            problems.push(`${said} cannot bind through ${quoted(name)}.`);
+        }
+        else if (name in fields) {
+            problems.push(`${said} both has the property ${quoted(name)} and binds through it.`);
+        }
+    }
+    for (const [bindings, what] of [
+        [component.shows, 'shows'],
+        [component.sends, 'sends'],
+    ]) {
+        if (new Set(bindings).size !== bindings.length) {
+            problems.push(`${said} ${what} the same binding twice.`);
+        }
+    }
+    if (component.example) {
+        const bindings = new Set([...component.shows, ...component.sends]);
+        const given = Object.fromEntries(Object.entries(component.example).filter(([key]) => !bindings.has(key)));
+        const refused = customPropsRefused(component, given);
+        if (refused.length > 0) {
+            problems.push(`${said}'s example is refused: ${refused.join('; ')}.`);
+        }
+    }
+    return problems;
+}
+/** What stops the components an application's developer wrote, in sentences. */
+export function customComponentsProblems(app) {
+    const own = app.interface.customComponents ?? [];
+    const problems = own.flatMap(customComponentProblems);
+    const names = own.map(component => component.name);
+    if (new Set(names).size !== names.length) {
+        problems.push('Two of its own components have the same name.');
+    }
+    return problems;
+}
+/** A component its developer wrote, by name, or undefined. */
+export function customComponentOf(app, name) {
+    return (app.interface.customComponents ?? []).find(component => component.name === name);
+}
+/**
+ * It as the catalog lists a component (C-13): what the palette, the
+ * components page and the checks read — under the application's version, its
+ * category `custom`.
+ */
+export function customComponentEntry(component, version) {
+    return {
+        id: component.name,
+        name: component.name,
+        description: component.description,
+        category: 'custom',
+        emoji: '🧩',
+        version,
+        standard: false,
+        properties: component.props,
+        bindings: { shows: [...component.shows], sends: [...component.sends] },
+        events: component.sends.length > 0 ? ['send'] : [],
+        ...(component.example ? { example: component.example } : {}),
+    };
+}
+/**
+ * The components an application may place: the catalog's own, given, and
+ * those its developer wrote, for it alone. A name of its own that the
+ * catalog has is not listed twice: the checks refuse it.
+ */
+export function appComponents(app, catalog) {
+    const names = new Set(catalog.map(component => component.id));
+    return [
+        ...catalog,
+        ...(app.interface.customComponents ?? [])
+            .filter(component => !names.has(component.name))
+            .map(component => customComponentEntry(component, app.version)),
+    ];
+}
+/** What its schema refuses of a node of a surface drawn by it, in sentences; empty when nothing. */
+export function customNodeRefused(component, node) {
+    const skip = new Set([
+        ...CUSTOM_RESERVED_NAMES,
+        ...component.shows,
+        ...component.sends,
+    ]);
+    const given = Object.fromEntries(Object.entries(node).filter(([key]) => !skip.has(key)));
+    const bound = Object.entries(given)
+        .filter(([, value]) => isBound(value))
+        .map(([key]) => key);
+    return customPropsRefused(component, given, bound);
+}

package/lib/loop/apps/hostTools.d.ts

@@ -6,12 +6,19 @@
  *
  * @module loop/apps/hostTools
  */
-import type { AppHostBridgeSpec } from '../../types/agentspecs';
+import type { AppHostBridgeSpec, AppHostUser } from '../../types/agentspecs';
 /** The tool its agent reads what the page passes it with. */
 export declare const HOST_CONTEXT_TOOL = "host_context";
 /** The tool its agent calls a function of the page with. */
 export declare const hostTool: (name: string) => string;
 /** How a value or a function of the host is named. */
 export declare const HOST_NAME: RegExp;
+/** What the page's word on its visitor may be worth (LOOP D-21). */
+export declare const HOST_USERS: readonly AppHostUser[];
+/**
+ * Whether a session is opened only for a user the host's server signed
+ * (LOOP D-21): `deployment.embedded.host.user: signed`.
+ */
+export declare function signedUser(bridge: AppHostBridgeSpec | undefined): boolean;
 /** The tools its agent is given for the host. */
 export declare function hostToolsOf(bridge: AppHostBridgeSpec | undefined): string[];

package/lib/loop/apps/hostTools.js

@@ -8,6 +8,15 @@ export const HOST_CONTEXT_TOOL = 'host_context';
 export const hostTool = (name) => `host_${name}`;
 /** How a value or a function of the host is named. */
 export const HOST_NAME = /^[a-z][a-z0-9_]{0,62}$/;
+/** What the page's word on its visitor may be worth (LOOP D-21). */
+export const HOST_USERS = ['claimed', 'signed'];
+/**
+ * Whether a session is opened only for a user the host's server signed
+ * (LOOP D-21): `deployment.embedded.host.user: signed`.
+ */
+export function signedUser(bridge) {
+    return bridge?.user === 'signed';
+}
 /** The tools its agent is given for the host. */
 export function hostToolsOf(bridge) {
     if (!bridge) {

package/lib/loop/apps/index.d.ts

@@ -18,3 +18,4 @@ export * from './records';
 export * from './rules';
 export * from './saved';
 export * from './yaml';
+export * from './customComponents';

package/lib/loop/apps/index.js

@@ -22,3 +22,4 @@ export * from './records';
 export * from './rules';
 export * from './saved';
 export * from './yaml';
+export * from './customComponents';

package/lib/loop/apps/language.d.ts

@@ -0,0 +1,68 @@
+/**
+ * An application in the person's language (LOOP P-26).
+ *
+ * An Appspec says its words in its own language (`interface.language`, `en`
+ * unless said) and may say them in others (`interface.translations`, by BCP
+ * 47 tag): its name, description and welcome, its starters by label and
+ * their categories, its settings' fields, its commands' descriptions, its
+ * modes and its profiles. The page shows the first language the person
+ * prefers that the application has — the browser's, unless its host says
+ * another — and its own words otherwise; what is not translated stays in its
+ * own words. Only what is shown changes: ids, values and prompts are the same
+ * in every language, and a starter's message is sent in the person's.
+ *
+ * agentspecs' `LANGUAGE_TAG`, `pick_language`, `AppSpec.translated` and the
+ * translation checks, said again for the page. The interface's own words —
+ * the composer's, the profile picker's — are {@link interfaceWords}.
+ *
+ * Pure: no React, no network ({@link preferredLanguages} reads the browser's).
+ *
+ * @module loop/apps/language
+ */
+import type { AppInterfaceSpec, AppSpec } from '../../types/agentspecs';
+/**
+ * A language as BCP 47 tags it: two or three letters, then optionally a
+ * script, a region and variants — `fr`, `pt-BR`, `zh-Hant-TW`.
+ */
+export declare const LANGUAGE_TAG: RegExp;
+/**
+ * The first language a person prefers that is available, or null. Tags are
+ * compared without case; a preferred tag also takes one of its language
+ * alone, then one of the same language (`fr-CA` takes `fr`, then `fr-FR`).
+ */
+export declare function pickLanguage(available: readonly string[], preferred: readonly string[]): string | null;
+/** The languages the browser says the person prefers, in their order; none outside one. */
+export declare function preferredLanguages(): string[];
+/** The language an application is read in by a person who prefers these. */
+export declare function appLanguage(app: Pick<AppSpec, 'interface'>, preferred: readonly string[]): string;
+/**
+ * The application as a person who prefers these languages reads it: its
+ * name, description and interface in the first of them it is translated
+ * into, else itself. What it does — its agent, its rules, its ids, its
+ * values, its prompts — is the same.
+ */
+export declare function translatedAppspec(app: AppSpec, preferred: readonly string[]): AppSpec;
+/**
+ * What is wrong with an application's translations, in agentspecs'
+ * sentences: its own language, and each translation's, a BCP 47 tag; no
+ * translation into its own language, nor into one twice; nothing translated
+ * that it does not say.
+ */
+export declare function translationProblems(ui: AppInterfaceSpec): string[];
+/** The words the application's interface says itself, in one language. */
+export type InterfaceWords = {
+    /** The profile picker's name. */
+    profile: string;
+    /** Beside the profile a conversation started with: it is kept. */
+    profileKept: string;
+    /** The paper clip's. */
+    attach: string;
+};
+/**
+ * The words the application's own interface says — the profile picker, the
+ * paper clip — in the languages it is said in. Another language reads
+ * English.
+ */
+export declare const INTERFACE_WORDS: Record<string, InterfaceWords>;
+/** The interface's own words in a language: its own, else its language's, else English. */
+export declare function interfaceWords(language: string): InterfaceWords;

package/lib/loop/apps/language.js

@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { DEFAULT_LANGUAGE } from './appspec';
+/**
+ * A language as BCP 47 tags it: two or three letters, then optionally a
+ * script, a region and variants — `fr`, `pt-BR`, `zh-Hant-TW`.
+ */
+export const LANGUAGE_TAG = /^[A-Za-z]{2,3}(?:-[A-Za-z]{4})?(?:-(?:[A-Za-z]{2}|[0-9]{3}))?(?:-(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$/;
+/**
+ * The first language a person prefers that is available, or null. Tags are
+ * compared without case; a preferred tag also takes one of its language
+ * alone, then one of the same language (`fr-CA` takes `fr`, then `fr-FR`).
+ */
+export function pickLanguage(available, preferred) {
+    const byTag = new Map(available.map(tag => [tag.toLowerCase(), tag]));
+    for (const wanted of preferred) {
+        const tag = wanted.trim().toLowerCase();
+        if (!tag) {
+            continue;
+        }
+        const exact = byTag.get(tag);
+        if (exact) {
+            return exact;
+        }
+        const language = tag.split('-')[0];
+        const alone = byTag.get(language);
+        if (alone) {
+            return alone;
+        }
+        for (const [candidate, original] of byTag) {
+            if (candidate.split('-')[0] === language) {
+                return original;
+            }
+        }
+    }
+    return null;
+}
+/** The languages the browser says the person prefers, in their order; none outside one. */
+export function preferredLanguages() {
+    if (typeof navigator === 'undefined') {
+        return [];
+    }
+    const languages = navigator.languages?.length
+        ? [...navigator.languages]
+        : [navigator.language];
+    return languages.filter(Boolean);
+}
+/** The language an application is read in by a person who prefers these. */
+export function appLanguage(app, preferred) {
+    const own = app.interface.language ?? DEFAULT_LANGUAGE;
+    return (pickLanguage([own, ...Object.keys(app.interface.translations ?? {})], preferred) ?? own);
+}
+function translatedStarter(starter, words) {
+    const said = words.starters[starter.label];
+    const category = starter.category
+        ? words.categories[starter.category] || starter.category
+        : undefined;
+    return {
+        label: said?.label || starter.label,
+        message: said?.message || starter.message,
+        ...(category ? { category } : {}),
+    };
+}
+/** The settings' uiSchema, a translated field's values named in the language. */
+function namedOptions(ui, words, settings) {
+    const named = Object.entries(words.settings).filter(([, field]) => Object.keys(field.options).length > 0);
+    if (named.length === 0 || !settings) {
+        return ui;
+    }
+    const drawn = JSON.parse(JSON.stringify(ui ?? {}));
+    for (const [name, field] of named) {
+        const schema = (settings.properties?.[name] ?? {});
+        const items = (schema.items ?? {});
+        const values = (schema.enum ?? items.enum ?? []).map(String);
+        drawn[name] = {
+            ...(drawn[name] ?? {}),
+            'ui:enumNames': values.map(value => field.options[value] ?? value),
+        };
+    }
+    return drawn;
+}
+/**
+ * The application as a person who prefers these languages reads it: its
+ * name, description and interface in the first of them it is translated
+ * into, else itself. What it does — its agent, its rules, its ids, its
+ * values, its prompts — is the same.
+ */
+export function translatedAppspec(app, preferred) {
+    const tag = appLanguage(app, preferred);
+    const words = app.interface.translations?.[tag];
+    if (!words) {
+        return app;
+    }
+    const ui = app.interface;
+    let settings = ui.settings;
+    if (settings && Object.keys(words.settings).length > 0) {
+        settings = JSON.parse(JSON.stringify(settings));
+        for (const [name, field] of Object.entries(words.settings)) {
+            const target = settings.properties?.[name];
+            if (!target) {
+                continue;
+            }
+            if (field.title) {
+                target.title = field.title;
+            }
+            if (field.description) {
+                target.description = field.description;
+            }
+        }
+    }
+    const settingsUi = namedOptions(ui.settingsUi, words, settings);
+    return {
+        ...app,
+        name: words.name || app.name,
+        description: words.description || app.description,
+        interface: {
+            ...ui,
+            welcome: words.welcome || ui.welcome,
+            starters: ui.starters.map(starter => translatedStarter(starter, words)),
+            commands: ui.commands.map(command => ({
+                ...command,
+                description: words.commands[command.name] || command.description,
+            })),
+            modes: ui.modes.map(mode => {
+                const said = words.modes[mode.id];
+                return said
+                    ? {
+                        ...mode,
+                        label: said.label || mode.label,
+                        options: mode.options.map(option => ({
+                            ...option,
+                            label: said.options[option.id]?.label || option.label,
+                            ...(said.options[option.id]?.description
+                                ? { description: said.options[option.id].description }
+                                : {}),
+                        })),
+                    }
+                    : mode;
+            }),
+            profiles: (ui.profiles ?? []).map(profile => ({
+                ...profile,
+                label: words.profiles[profile.id]?.label || profile.label,
+                description: words.profiles[profile.id]?.description || profile.description,
+                starters: profile.starters.map(starter => translatedStarter(starter, words)),
+            })),
+            ...(settings ? { settings } : {}),
+            ...(settingsUi ? { settingsUi } : {}),
+            language: tag,
+            translations: {},
+        },
+    };
+}
+/**
+ * What is wrong with an application's translations, in agentspecs'
+ * sentences: its own language, and each translation's, a BCP 47 tag; no
+ * translation into its own language, nor into one twice; nothing translated
+ * that it does not say.
+ */
+export function translationProblems(ui) {
+    const own = ui.language ?? DEFAULT_LANGUAGE;
+    const problems = [];
+    if (!LANGUAGE_TAG.test(own)) {
+        problems.push(`“${own}” is no language as BCP 47 tags it: \`en\`, \`fr\`, \`pt-BR\`.`);
+    }
+    const profiles = ui.profiles ?? [];
+    const starters = new Set([
+        ...ui.starters.map(starter => starter.label),
+        ...profiles.flatMap(profile => profile.starters.map(item => item.label)),
+    ]);
+    const categories = new Set([...ui.starters, ...profiles.flatMap(profile => profile.starters)]
+        .map(starter => starter.category)
+        .filter(Boolean));
+    const fields = (ui.settings?.properties ?? {});
+    const seen = new Map();
+    for (const [tag, words] of Object.entries(ui.translations ?? {})) {
+        if (!LANGUAGE_TAG.test(tag)) {
+            problems.push(`The translation “${tag}” is of no language as BCP 47 tags it: \`fr\`, \`pt-BR\`.`);
+            continue;
+        }
+        if (tag.toLowerCase() === own.toLowerCase()) {
+            problems.push(`Its own words are in “${own}”: no translation into it.`);
+            continue;
+        }
+        const first = seen.get(tag.toLowerCase());
+        if (first) {
+            problems.push(`“${first}” and “${tag}” are the same language.`);
+            continue;
+        }
+        seen.set(tag.toLowerCase(), tag);
+        const unknown = [
+            ...Object.keys(words.starters)
+                .filter(label => !starters.has(label))
+                .map(label => `the starter “${label}”`),
+            ...Object.keys(words.categories)
+                .filter(name => !categories.has(name))
+                .map(name => `the category “${name}”`),
+            ...Object.keys(words.settings)
+                .filter(name => !(name in fields))
+                .map(name => `the setting “${name}”`),
+            ...Object.keys(words.commands)
+                .filter(name => !ui.commands.some(command => command.name === name))
+                .map(name => `the command “${name}”`),
+            ...Object.entries(words.modes).flatMap(([id, mode]) => {
+                const known = ui.modes.find(item => item.id === id);
+                if (!known) {
+                    return [`the mode “${id}”`];
+                }
+                return Object.keys(mode.options)
+                    .filter(option => !known.options.some(item => item.id === option))
+                    .map(option => `the option “${option}” of “${id}”`);
+            }),
+            ...Object.keys(words.profiles)
+                .filter(id => !profiles.some(profile => profile.id === id))
+                .map(id => `the profile “${id}”`),
+            ...Object.entries(words.settings).flatMap(([name, field]) => {
+                const schema = (fields[name] ?? {});
+                const items = (schema.items ?? {});
+                const values = (schema.enum ?? items.enum ?? []).map(String);
+                return name in fields
+                    ? Object.keys(field.options)
+                        .filter(value => !values.includes(value))
+                        .map(value => `the value “${value}” of “${name}”`)
+                    : [];
+            }),
+        ];
+        if (unknown.length > 0) {
+            problems.push(`The translation “${tag}” translates what the application does not say: ${unknown.join(', ')}.`);
+        }
+    }
+    return problems;
+}
+/**
+ * The words the application's own interface says — the profile picker, the
+ * paper clip — in the languages it is said in. Another language reads
+ * English.
+ */
+export const INTERFACE_WORDS = {
+    en: {
+        profile: 'Profile',
+        profileKept: 'kept for this conversation',
+        attach: 'Attach a file',
+    },
+    fr: {
+        profile: 'Profil',
+        profileKept: 'gardé pour cette conversation',
+        attach: 'Joindre un fichier',
+    },
+    es: {
+        profile: 'Perfil',
+        profileKept: 'se mantiene en esta conversación',
+        attach: 'Adjuntar un archivo',
+    },
+    de: {
+        profile: 'Profil',
+        profileKept: 'für dieses Gespräch beibehalten',
+        attach: 'Datei anhängen',
+    },
+    it: {
+        profile: 'Profilo',
+        profileKept: 'mantenuto per questa conversazione',
+        attach: 'Allega un file',
+    },
+    pt: {
+        profile: 'Perfil',
+        profileKept: 'mantido nesta conversa',
+        attach: 'Anexar um arquivo',
+    },
+};
+/** The interface's own words in a language: its own, else its language's, else English. */
+export function interfaceWords(language) {
+    const tag = pickLanguage(Object.keys(INTERFACE_WORDS), [language]);
+    return INTERFACE_WORDS[tag ?? 'en'];
+}

package/lib/loop/apps/settingsInputs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The nine inputs a setting is drawn with (LOOP P-20): each a JSON Schema
+ * field and, where the field's own widget is not the one wanted, the widget a
+ * form's uiSchema names for it (`ui:widget`) — what `@datalayer/primer-rjsf`
+ * draws. agentspecs' `SETTING_INPUTS`, `FORM_WIDGETS` and
+ * `form_ui_problems`, said again for the page, in its sentences.
+ *
+ * Pure: no React, no network.
+ *
+ * @module loop/apps/settingsInputs
+ */
+/** The nine inputs: the field each is, and the widget it is drawn with. */
+export declare const SETTING_INPUTS: Record<string, {
+    field: string;
+    widget: string;
+}>;
+/** The widgets a form's `ui` may name (`ui:widget`). */
+export declare const FORM_WIDGETS: readonly ["select", "radio", "range", "updown", "switch", "checkbox", "text", "textarea", "date", "checkboxes", "tags"];
+type Data = Record<string, unknown>;
+/** Why a widget cannot draw a field, in words; null when it can. */
+export declare function widgetRefusal(widget: string, field: Data): string | null;
+/**
+ * What is wrong with how a form's fields are drawn, in agentspecs'
+ * `form_ui_problems` sentences: by field name, the `ui:` options of each —
+ * `ui:widget` one of {@link FORM_WIDGETS} that draws the field — and
+ * `ui:order` at its top.
+ */
+export declare function formUiProblems(said: string, schema: Data, ui: unknown): string[];
+export {};