@datalayer/agent-runtimes 1.3.83 → 1.3.84

package/lib/loop/apps/composer.js

@@ -44,18 +44,51 @@ export function modeChoice(app, chosen = {}) {
     return { ...modeDefaults(app), ...chosen };
 }
 /**
- * What a run in the modes chosen is told, and the model it runs on —
- * agentspecs' `mode_effect`: the instructions of every option chosen, in the
- * order of the modes, and the model of the first that names one. Refused as
- * {@link modeChoice} refuses.
+ * The profile a conversation is with (LOOP P-20): the one chosen, else the
+ * first; undefined for an application without profiles. One it does not have
+ * is refused, in a sentence, as the runtime refuses it.
  */
-export function modeEffect(app, chosen = {}) {
+export function profileChoice(app, chosen) {
+    const profiles = app.interface.profiles ?? [];
+    if (chosen) {
+        const profile = profiles.find(candidate => candidate.id === chosen);
+        if (!profile) {
+            throw new Error(profiles.length === 0
+                ? `${app.name} has no profiles: “${chosen}” cannot be chosen.`
+                : `${app.name} has no profile “${chosen}”.`);
+        }
+        return profile;
+    }
+    return profiles[0];
+}
+/** The starters offered with a profile: its own, else the application's (P-20). */
+export function startersFor(app, profile) {
+    const chosen = profileChoice(app, profile);
+    return chosen && chosen.starters.length > 0
+        ? chosen.starters
+        : app.interface.starters;
+}
+/**
+ * What a run in the modes chosen, with the profile chosen, is told, and the
+ * model it runs on — agentspecs' `mode_effect`, and the runtime's
+ * `run_effect`: the profile's instructions first, then those of every option
+ * chosen, in the order of the modes; the model of the first option that
+ * names one, else the profile's. Refused as {@link modeChoice} and
+ * {@link profileChoice} refuse.
+ */
+export function modeEffect(app, chosen = {}, profile) {
     const choice = modeChoice(app, chosen);
+    const withProfile = profileChoice(app, profile);
     const options = (app.interface.modes ?? []).flatMap(mode => mode.options.filter(option => option.id === choice[mode.id]));
-    const instructions = options
-        .map(option => (option.instructions ?? '').trim())
+    const instructions = [
+        withProfile?.instructions ?? '',
+        ...options.map(option => option.instructions ?? ''),
+    ]
+        .map(part => part.trim())
         .filter(Boolean)
         .join('\n\n');
-    const model = options.find(option => option.model)?.model ?? undefined;
+    const model = options.find(option => option.model)?.model ??
+        withProfile?.model ??
+        undefined;
     return model ? { instructions, model } : { instructions };
 }

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 {};

package/lib/loop/apps/settingsInputs.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * 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 const SETTING_INPUTS = {
+    Select: { field: 'a field with an `enum`', widget: 'select (its own)' },
+    Slider: {
+        field: 'a `number` or an `integer` with a `minimum` and a `maximum`',
+        widget: 'range',
+    },
+    Switch: { field: 'a `boolean`', widget: 'switch' },
+    TextInput: { field: 'a `string`', widget: 'text (its own), or textarea' },
+    Checkbox: { field: 'a `boolean`', widget: 'checkbox (its own)' },
+    DatePicker: {
+        field: 'a `string` of `format: date`',
+        widget: 'date (its own)',
+    },
+    MultiSelect: {
+        field: 'an `array` of `uniqueItems` whose `items` have an `enum`',
+        widget: 'select (its own), or checkboxes',
+    },
+    RadioGroup: { field: 'a field with an `enum`', widget: 'radio' },
+    Tags: {
+        field: 'an `array` of `string` items without an `enum`',
+        widget: 'tags',
+    },
+};
+/** The widgets a form's `ui` may name (`ui:widget`). */
+export const FORM_WIDGETS = [
+    'select',
+    'radio',
+    'range',
+    'updown',
+    'switch',
+    'checkbox',
+    'text',
+    'textarea',
+    'date',
+    'checkboxes',
+    'tags',
+];
+const isData = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Why a widget cannot draw a field, in words; null when it can. */
+export function widgetRefusal(widget, field) {
+    const kind = field.type;
+    const items = isData(field.items) ? field.items : {};
+    switch (widget) {
+        case 'select':
+        case 'radio':
+            if ('enum' in field || (widget === 'radio' && kind === 'boolean')) {
+                return null;
+            }
+            if (widget === 'select' && kind === 'array' && 'enum' in items) {
+                return null;
+            }
+            return 'draws a choice: the field has an `enum`';
+        case 'range':
+            return (kind === 'number' || kind === 'integer') &&
+                'minimum' in field &&
+                'maximum' in field
+                ? null
+                : 'is a slider: a `number` or an `integer` with a `minimum` and a `maximum`';
+        case 'updown':
+            return kind === 'number' || kind === 'integer'
+                ? null
+                : 'draws a `number` or an `integer`';
+        case 'switch':
+        case 'checkbox':
+            return kind === 'boolean' ? null : 'draws a `boolean`';
+        case 'text':
+        case 'textarea':
+            return kind === 'string' ? null : 'draws a `string`';
+        case 'date':
+            return kind === 'string' ? null : 'draws a `string` of `format: date`';
+        case 'checkboxes':
+            return kind === 'array' && 'enum' in items
+                ? null
+                : 'draws an `array` whose `items` have an `enum`';
+        case 'tags':
+            return kind === 'array' && items.type === 'string' && !('enum' in items)
+                ? null
+                : 'draws an `array` of `string` items without an `enum`';
+        default:
+            return `is no widget: ${FORM_WIDGETS.join(', ')}`;
+    }
+}
+const quoted = (value) => `“${String(value)}”`;
+/**
+ * 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 function formUiProblems(said, schema, ui) {
+    if (!isData(ui)) {
+        return [`${said} is drawn by field name: its \`ui\` is a mapping.`];
+    }
+    const fields = isData(schema.properties) ? schema.properties : {};
+    const problems = [];
+    for (const [name, options] of Object.entries(ui)) {
+        if (name === 'ui:order') {
+            const order = Array.isArray(options) ? options : null;
+            const unknown = (order ?? []).filter(item => item !== '*' && !(String(item) in fields));
+            if (order === null || unknown.length > 0) {
+                problems.push(`${said} orders fields it does not ask: ${unknown.map(quoted).join(', ') || String(options)}.`);
+            }
+            continue;
+        }
+        if (name.startsWith('ui:')) {
+            continue;
+        }
+        if (!(name in fields)) {
+            problems.push(`${said} says how to draw ${quoted(name)}, which it does not ask.`);
+            continue;
+        }
+        if (!isData(options)) {
+            problems.push(`${said}'s field ${quoted(name)} is drawn with \`ui:\` options, a mapping.`);
+            continue;
+        }
+        const wrong = Object.keys(options).filter(key => !key.startsWith('ui:') && key !== 'items');
+        if (wrong.length > 0) {
+            problems.push(`${said}'s field ${quoted(name)} is drawn with \`ui:\` options, not ${wrong.map(quoted).join(', ')}.`);
+        }
+        const widget = options['ui:widget'];
+        const field = fields[name];
+        if (widget === undefined || !isData(field)) {
+            continue;
+        }
+        const refusal = widgetRefusal(String(widget), field);
+        if (refusal) {
+            problems.push(`${said}'s field ${quoted(name)} is drawn with ${quoted(widget)}, which ${refusal}.`);
+        }
+    }
+    return problems;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * What a person sends (LOOP P-21), as rules: the kinds of file an
+ * application takes in its composer without asking (`interface.uploads`),
+ * each with its largest size, and how many at once — and why a file is
+ * refused, in the sentence the runtime says when it was sent all the same.
+ * agentspecs' own (`AppUploads.refusal`, `too_many`, `upload_kind_takes`),
+ * said again for the page.
+ *
+ * Pure: no React, no network.
+ *
+ * @module loop/apps/uploads
+ */
+import type { AppSpec, AppUploadsSpec } from '../../types/agentspecs';
+/** The largest file a person may send an application, in megabytes. */
+export declare const MAX_UPLOAD_MB = 25;
+/** What a kind takes when it does not say, in megabytes. */
+export declare const DEFAULT_UPLOAD_MB = 10;
+/** How many files go with one message when it does not say. */
+export declare const DEFAULT_MAX_FILES = 5;
+/** A media type, a family of them, or an extension, lowercase. */
+export declare const UPLOAD_KIND: RegExp;
+/** A file as the person gives it: its name, its type, its size in bytes. */
+export type SentFile = {
+    name: string;
+    type: string;
+    size: number;
+};
+/**
+ * Whether a kind of file takes a file: an extension (`.csv`) by its name, a
+ * media type (`application/pdf`) or a family (`image/*`) by its type.
+ */
+export declare function kindTakes(kind: string, file: Pick<SentFile, 'name' | 'type'>): boolean;
+/** Whether any of `kinds` takes a file; any file when there are none. */
+export declare const acceptsFile: (kinds: readonly string[] | undefined, file: Pick<SentFile, "name" | "type">) => boolean;
+/** The `accept` of a file input for what the application takes. */
+export declare const uploadsAccept: (uploads: AppUploadsSpec) => string;
+/**
+ * Why files sent without being asked are refused, in a sentence — the
+ * runtime's — or `null` when the application takes every one of them.
+ */
+export declare function uploadsRefusal(app: Pick<AppSpec, 'name' | 'interface'>, files: readonly SentFile[]): string | null;
+/** What the composer says it takes, in a sentence. */
+export declare function uploadsInWords(uploads: AppUploadsSpec): string;