@datalayer/agent-runtimes 1.3.83 → 1.3.85

package/lib/loop/apps/checks.js

@@ -39,10 +39,14 @@ import { getTeamSpec } from '../../specs/teams';
 import { getBackendToolSpec } from '../../specs/backendTools';
 import { getTrack } from '../../specs/tracks';
 import { pluginsOffSetupNotes } from '../plugins/canvas-blocks';
-import { APP_THEME_MODES, APP_THEME_VARIANTS, isAssistantCharacterId, parseAppspec, } from './appspec';
+import { APP_THEME_MODES, APP_THEME_VARIANTS, isAssistantCharacterId, PAGE_OUTPUT_SHOWS, parseAppspec, } from './appspec';
 import { classesOf, splitRef, toolBehaviours } from './rules';
 import { COMMAND_INPUT, COMMAND_NAME, MODE_ID } from './composer';
-import { HOST_NAME, hostToolsOf } from './hostTools';
+import { HOST_NAME, HOST_USERS, hostToolsOf } from './hostTools';
+import { MAX_UPLOAD_MB, UPLOAD_KIND } from './uploads';
+import { formUiProblems } from './settingsInputs';
+import { customComponentOf, customComponentsProblems, customNodeRefused, customPropsRefused, } from './customComponents';
+import { translationProblems } from './language';
 export const NOT_READY = 'Not ready';
 export const NEEDS_ATTENTION = 'Needs attention';
 export const PASSES = 'Passes the instant checks';
@@ -80,6 +84,130 @@ const matches = (name, pattern) => new RegExp('^' +
             ? '[\\s\\S]'
             : c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('') +
     '$').test(name);
+/** The name of a function of an application's code (agentspecs' `CODE_NAME`). */
+const CODE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * What its code declares that agentspecs refuses (LOOP P-06): its tools,
+ * its checks and the tests it decides, each by a Python name, each name
+ * once; a tool says what it does, by class, each class once.
+ */
+export function ownCodeProblems(app) {
+    const problems = [];
+    const tools = app.tools ?? [];
+    for (const tool of tools) {
+        if (!CODE_NAME.test(tool.name)) {
+            problems.push(`Cannot use “${tool.name}” as a tool's name: letters, digits and \`_\`, as in Python.`);
+        }
+        if (!tool.description.trim()) {
+            problems.push(`The tool “${tool.name}” says what it does, for the agent.`);
+        }
+        if (tool.does.length === 0) {
+            problems.push(`The tool “${tool.name}” says what it does: read, write, send, buy, delete or publish.`);
+        }
+        for (const action of tool.does) {
+            if (!CLASS_NAMES.has(action)) {
+                problems.push(`The tool “${tool.name}” does “${action}”, which is no class of action.`);
+            }
+        }
+        if (new Set(tool.does).size !== tool.does.length) {
+            problems.push('A tool says each thing it does once.');
+        }
+    }
+    const names = tools.map(tool => tool.name);
+    if (new Set(names).size !== names.length) {
+        problems.push('Two of its tools have the same name.');
+    }
+    const checks = (app.checks.code ?? []).map(check => check.name);
+    for (const name of checks) {
+        if (!CODE_NAME.test(name)) {
+            problems.push(`Cannot use “${name}” as a check's name: letters, digits and \`_\`, as in Python.`);
+        }
+    }
+    if (new Set(checks).size !== checks.length) {
+        problems.push('Two checks of its code have the same name.');
+    }
+    const decided = app.tests.cases.flatMap(testCase => testCase.code ? [testCase.code] : []);
+    if (new Set(decided).size !== decided.length) {
+        problems.push('Two tests are decided by the same function of its code.');
+    }
+    problems.push(...pageProblems(app));
+    // The components its developer wrote, reviewed as the catalog's (P-17).
+    problems.push(...customComponentsProblems(app));
+    return problems;
+}
+/**
+ * What agentspecs refuses of a widget's page written in its code (LOOP
+ * P-05): a page that is not a widget's, inputs that are not a form, outputs
+ * of one name twice, drawn with another component, saying in their `props`
+ * what their value fills or lacking what their component needs, and an input
+ * named as a setting — both are on the page at `/inputs/<name>`.
+ */
+export function pageProblems(app) {
+    const page = app.interface.page;
+    if (!page) {
+        return [];
+    }
+    const problems = [];
+    if (app.kind !== 'widget') {
+        problems.push(`A page of inputs and outputs is a widget's: a ${app.kind} application has none. Remove \`interface.page\`, or make it a widget.`);
+    }
+    if (!CODE_NAME.test(page.function)) {
+        problems.push(`Cannot use “${page.function}” as the function of its page: letters, digits and \`_\`, as in Python.`);
+    }
+    problems.push(...formProblems({
+        id: 'page inputs',
+        schema: page.inputs,
+        ui: page.inputsUi,
+    }));
+    if (page.outputs.length === 0) {
+        problems.push('Its page shows one output at least.');
+    }
+    const names = page.outputs.map(output => output.name);
+    if (new Set(names).size !== names.length) {
+        problems.push('Two outputs of its page have the same name.');
+    }
+    for (const output of page.outputs) {
+        if (!CODE_NAME.test(output.name)) {
+            problems.push(`Cannot use “${output.name}” as an output's name: letters, digits and \`_\`, as in Python.`);
+        }
+        // A component its developer wrote (P-17): its value what it shows first.
+        const custom = output.component in PAGE_OUTPUT_SHOWS
+            ? undefined
+            : customComponentOf(app, output.component);
+        if (custom) {
+            if (custom.shows.length === 0) {
+                problems.push(`The output “${output.name}” is drawn with ${output.component}, which shows nothing: its value is what it shows first, under \`shows\`.`);
+                continue;
+            }
+            const refused = customPropsRefused(custom, output.props);
+            if (refused.length > 0) {
+                problems.push(`The output “${output.name}” is a ${output.component} its schema refuses: ${refused.join('; ')}.`);
+            }
+            continue;
+        }
+        const shows = PAGE_OUTPUT_SHOWS[output.component];
+        if (!shows) {
+            problems.push(`The output “${output.name}” is drawn with ${output.component}: an output is one of ${Object.keys(PAGE_OUTPUT_SHOWS).join(', ')} or a component of its own (\`custom_components\`).`);
+            continue;
+        }
+        const said = [shows, 'id', 'component'].filter(key => key in output.props);
+        if (said.length > 0) {
+            problems.push(`The output “${output.name}” says ${said.join(', ')} in its \`props\`: its id is its name, and what it shows is its value.`);
+        }
+        const schema = getComponent(output.component)?.properties;
+        const missing = (schema?.required ?? []).filter(key => key !== shows && !(key in output.props));
+        if (missing.length > 0) {
+            problems.push(`The output “${output.name}” is a ${output.component} without ${missing.join(', ')}: say it in its \`props\`.`);
+        }
+    }
+    const settings = Object.keys(app.interface.settings?.properties ?? {});
+    const inputs = Object.keys(page.inputs?.properties ?? {});
+    const shared = settings.filter(name => inputs.includes(name));
+    if (shared.length > 0) {
+        problems.push(`${shared.map(name => `“${name}”`).join(', ')} is both a setting and an input of its page: name one otherwise.`);
+    }
+    return problems;
+}
 /** What the spec says of itself that the tolerant reader lets through. */
 function shapeProblems(app) {
     const problems = [];
@@ -120,6 +248,36 @@ function shapeProblems(app) {
     else if (app.triggers.length > 0) {
         problems.push(`A ${app.kind} application starts when somebody opens it: \`triggers\` are a worker's.`);
     }
+    // Its profiles (LOOP P-20): two at least, or none; each id slash-safe and
+    // said once, each with a label.
+    const profiles = app.interface.profiles ?? [];
+    if (profiles.length === 1) {
+        problems.push('One profile is the application itself: say two at least, or put its instructions, model and starters on the application.');
+    }
+    const profileIds = new Set();
+    for (const profile of profiles) {
+        if (!MODE_ID.test(profile.id)) {
+            problems.push(`Cannot use “${profile.id}” as a profile's id: lower-case letters, digits, \`_\` and \`-\`, a letter first.`);
+        }
+        if (!profile.label.trim()) {
+            problems.push(`The profile “${profile.id}” has no label.`);
+        }
+        if (profileIds.has(profile.id)) {
+            problems.push(`Two profiles are “${profile.id}”.`);
+        }
+        profileIds.add(profile.id);
+    }
+    // How its settings' fields are drawn (P-20): by a widget that draws each.
+    if (app.interface.settingsUi) {
+        if (!app.interface.settings) {
+            problems.push('`settings_ui` draws the settings’ fields: say `settings` first.');
+        }
+        else {
+            problems.push(...formUiProblems('The form “settings”', app.interface.settings, app.interface.settingsUi));
+        }
+    }
+    // Its words in other languages (P-26): of languages, of what it says.
+    problems.push(...translationProblems(app.interface));
     // What the host page passes and offers (D-10): named once each, in words
     // its agent's tools can carry, each function saying what it does.
     const host = app.deployment.embedded?.host;
@@ -147,6 +305,10 @@ function shapeProblems(app) {
         if (new Set(names).size !== names.length) {
             problems.push('The host’s functions are named once each.');
         }
+        // Who its user is (D-21): what the page says, or what its server signed.
+        if (host.user !== undefined && !HOST_USERS.includes(host.user)) {
+            problems.push(`“${host.user}” is not how the host’s user is taken: claimed or signed.`);
+        }
         const named = new Set(app.rules.flatMap(rule => rule.appliesTo));
         for (const tool of hostToolsOf(host)) {
             if (!named.has(tool)) {
@@ -154,6 +316,8 @@ function shapeProblems(app) {
             }
         }
     }
+    // What its code declares (LOOP P-06), as agentspecs refuses it.
+    problems.push(...ownCodeProblems(app));
     const servers = app.connections.map(connection => idOf(connection.server));
     if (new Set(servers).size !== servers.length) {
         problems.push('The application connects to the same server twice.');
@@ -212,6 +376,10 @@ export function formProblems(node) {
     if (missing.length > 0) {
         problems.push(`${said} requires ${missing.map(name => `“${String(name)}”`).join(', ')}, which it does not ask.`);
     }
+    // How its fields are drawn (P-20): by a widget that draws each.
+    if (node.ui !== undefined && node.ui !== null) {
+        problems.push(...formUiProblems(said, schema, node.ui));
+    }
     return problems;
 }
 const isPlainRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -278,6 +446,12 @@ function referenceProblems(app, organizationFrames) {
     if (app.model && !getModel(app.model)) {
         missing('model', app.model);
     }
+    // The model a profile runs on is the catalogue's (LOOP P-20).
+    for (const profile of app.interface.profiles ?? []) {
+        if (profile.model && !getModel(profile.model)) {
+            problems.push(`The profile “${profile.id}” runs on “${profile.model}”, which is no model.`);
+        }
+    }
     // The model a mode runs on is the catalogue's (LOOP P-19).
     for (const mode of app.interface.modes ?? []) {
         for (const option of mode.options) {
@@ -287,13 +461,21 @@ function referenceProblems(app, organizationFrames) {
         }
     }
     // The components it may use, and those its surface uses, are the catalog's (C-13).
+    // Those its developer wrote are of the catalog for it alone (P-17).
     for (const name of app.interface.components ?? []) {
-        if (!componentNamed(name)) {
+        if (!componentNamed(name) && !customComponentOf(app, name)) {
             problems.push(`There is no component named “${name}” in the catalog.`);
         }
     }
     for (const node of app.interface.surface?.components ?? []) {
-        if (!componentNamed(String(node.component))) {
+        const custom = customComponentOf(app, String(node.component));
+        if (custom) {
+            const refused = customNodeRefused(custom, node);
+            if (refused.length > 0) {
+                problems.push(`The surface's “${String(node.id)}” is a ${custom.name} its schema refuses: ${refused.join('; ')}.`);
+            }
+        }
+        else if (!componentNamed(String(node.component))) {
             problems.push(`The surface's “${String(node.id)}” is a “${String(node.component)}”, which the catalog does not have.`);
         }
         else if (node.component === 'Form') {
@@ -336,6 +518,9 @@ function referenceProblems(app, organizationFrames) {
             if (server === undefined) {
                 if (hostTools.includes(target))
                     continue;
+                // A tool of its own, written in its code (LOOP P-06).
+                if ((app.tools ?? []).some(tool => tool.name === target))
+                    continue;
                 if (!getBackendToolSpec(name)) {
                     problems.push(`The rule “${rule.action}” names the tool “${target}”, which the catalogue does not have.`);
                 }
@@ -646,9 +831,44 @@ export function documentShapeProblems(document) {
         }
         text(ui.welcome, 'interface.welcome');
         texts(ui.components, 'interface.components');
-        records(ui.starters, 'interface.starters', (item, where) => {
+        const starter = (item, where) => {
             required(item, 'label', where);
             required(item, 'message', where);
+            text(item.category, `${where}.category`);
+            unknownKeys(item, ['label', 'message', 'category'], where, 'a starter');
+        };
+        records(ui.starters, 'interface.starters', starter);
+        // Its profiles (LOOP P-20), as agentspecs refuses them: no key unknown.
+        records(ui.profiles, 'interface.profiles', (profile, where) => {
+            required(profile, 'id', where);
+            required(profile, 'label', where);
+            for (const key of [
+                'id',
+                'label',
+                'description',
+                'instructions',
+                'model',
+            ]) {
+                text(profile[key], `${where}.${key}`);
+            }
+            unknownKeys(profile, ['id', 'label', 'description', 'instructions', 'model', 'starters'], where, 'a profile');
+            records(profile.starters, `${where}.starters`, starter);
+        });
+        text(ui.language, 'interface.language');
+        mapping(ui.translations, 'interface.translations', translations => {
+            for (const [tag, words] of Object.entries(translations)) {
+                mapping(words, `interface.translations.${tag}`, said => unknownKeys(said, [
+                    'name',
+                    'description',
+                    'welcome',
+                    'starters',
+                    'categories',
+                    'settings',
+                    'commands',
+                    'modes',
+                    'profiles',
+                ], `interface.translations.${tag}`, 'a translation'));
+            }
         });
         // Its commands and modes in the composer (LOOP P-19), as agentspecs
         // refuses them: names and ids slash-safe and said once, no key unknown.
@@ -738,11 +958,62 @@ export function documentShapeProblems(document) {
                 problems.push(...formProblems({ id: 'settings', schema: settings }));
             });
         }
+        // What a person may send without being asked (LOOP P-21), as agentspecs
+        // refuses it: a kind at least, each a type said once, sizes it takes.
+        mapping(ui.uploads, 'interface.uploads', uploads => {
+            unknownKeys(uploads, ['kinds', 'max_files'], 'interface.uploads', 'uploads');
+            required(uploads, 'kinds', 'interface.uploads');
+            const types = new Set();
+            records(uploads.kinds, 'interface.uploads.kinds', (kind, where) => {
+                required(kind, 'type', where);
+                unknownKeys(kind, ['type', 'max_mb'], where, 'a kind of upload');
+                if (kind.type !== undefined) {
+                    if (typeof kind.type !== 'string' || !UPLOAD_KIND.test(kind.type)) {
+                        at(`${where}.type`, 'is a media type (application/pdf), a family (image/*) or an extension (.csv), lowercase');
+                    }
+                    else if (types.has(kind.type)) {
+                        at(`${where}.type`, `names ${kind.type} a second time`);
+                    }
+                    else {
+                        types.add(kind.type);
+                    }
+                }
+                const size = kind.max_mb;
+                if (size !== undefined &&
+                    (typeof size !== 'number' || size <= 0 || size > MAX_UPLOAD_MB)) {
+                    at(`${where}.max_mb`, `is more than 0 and ${MAX_UPLOAD_MB} at most`);
+                }
+            });
+            if (Array.isArray(uploads.kinds) && uploads.kinds.length === 0) {
+                at('interface.uploads.kinds', 'are one at least');
+            }
+            const most = uploads.max_files;
+            if (most !== undefined &&
+                (typeof most !== 'number' ||
+                    !Number.isInteger(most) ||
+                    most < 1 ||
+                    most > 20)) {
+                at('interface.uploads.max_files', 'is a whole number from 1 to 20');
+            }
+        });
         mapping(ui.surface, 'interface.surface', surface => {
             records(surface.components, 'interface.surface.components', (item, where) => {
                 required(item, 'id', where);
                 required(item, 'component', where);
             });
+        }); // A widget's page written in its code (LOOP P-05), as agentspecs reads it.
+        mapping(ui.page, 'interface.page', page => {
+            unknownKeys(page, ['function', 'inputs', 'inputs_ui', 'outputs', 'live'], 'interface.page', 'a page');
+            required(page, 'function', 'interface.page');
+            required(page, 'inputs', 'interface.page');
+            required(page, 'outputs', 'interface.page');
+            if (page.live !== undefined && typeof page.live !== 'boolean') {
+                at('interface.page.live', 'is true or false');
+            }
+            records(page.outputs, 'interface.page.outputs', (output, where) => {
+                required(output, 'name', where);
+                unknownKeys(output, ['name', 'title', 'component', 'props'], where, 'an output');
+            });
         });
     });
     mapping(d.tests, 'tests', tests => {

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

@@ -1,14 +1,15 @@
 /**
- * Commands and modes in the composer (LOOP P-19), as rules: what a command
- * sends, and which option of each mode a run is in. agentspecs' own
- * (`command_prompt`, `AppInterface.mode_choice`, `mode_effect`), said again
- * for the page.
+ * Commands, modes and profiles in the composer (LOOP P-19, P-20), as rules:
+ * what a command sends, which option of each mode a run is in, which profile
+ * a conversation is with and what it offers. agentspecs' own
+ * (`command_prompt`, `AppInterface.mode_choice`, `mode_effect`,
+ * `profile_choice`, `starters_for`), said again for the page.
  *
  * Pure: no React, no network.
  *
  * @module loop/apps/composer
  */
-import type { AppCommandSpec, AppModeEffect, AppSpec } from '../../types/agentspecs';
+import type { AppCommandSpec, AppModeEffect, AppProfileSpec, AppSpec, AppStarterSpec } from '../../types/agentspecs';
 /** Where a command's prompt takes the words typed after it. */
 export declare const COMMAND_INPUT = "{input}";
 /** What follows the slash: lower-case letters, digits and hyphens, a letter first. */
@@ -29,9 +30,19 @@ export declare function modeDefaults(app: Pick<AppSpec, 'interface'>): Record<st
  */
 export declare function modeChoice(app: Pick<AppSpec, 'name' | 'interface'>, chosen?: Record<string, string>): Record<string, string>;
 /**
- * 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 declare function modeEffect(app: Pick<AppSpec, 'name' | 'interface'>, chosen?: Record<string, string>): AppModeEffect;
+export declare function profileChoice(app: Pick<AppSpec, 'name' | 'interface'>, chosen?: string): AppProfileSpec | undefined;
+/** The starters offered with a profile: its own, else the application's (P-20). */
+export declare function startersFor(app: Pick<AppSpec, 'name' | 'interface'>, profile?: string): AppStarterSpec[];
+/**
+ * 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 declare function modeEffect(app: Pick<AppSpec, 'name' | 'interface'>, chosen?: Record<string, string>, profile?: string): AppModeEffect;

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/customComponents.d.ts

@@ -0,0 +1,41 @@
+import type { AppCustomComponentSpec, AppSpec, ComponentSpec } from '../../types/agentspecs';
+/** Its name: a word starting with a capital letter, as the catalog's are named. */
+export declare const CUSTOM_COMPONENT_NAME: RegExp;
+/** What one of its properties may be typed: what the renderer tells apart. */
+export declare const CUSTOM_PROPERTY_TYPES: readonly ["string", "integer", "number", "boolean", "array", "object"];
+/** What every component of a surface already has, and a custom one cannot declare. */
+export declare const CUSTOM_RESERVED_NAMES: readonly ["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 declare const CUSTOM_SOURCE: RegExp;
+/** A Subresource Integrity hash: the module as it was reviewed. */
+export declare const INTEGRITY: RegExp;
+/**
+ * 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 declare function customPropsRefused(component: AppCustomComponentSpec, props: Record<string, unknown>, bound?: readonly string[]): string[];
+/** What stops one component its developer wrote from being reviewed, in sentences. */
+export declare function customComponentProblems(component: AppCustomComponentSpec): string[];
+/** What stops the components an application's developer wrote, in sentences. */
+export declare function customComponentsProblems(app: AppSpec): string[];
+/** A component its developer wrote, by name, or undefined. */
+export declare function customComponentOf(app: Pick<AppSpec, 'interface'>, name: string): AppCustomComponentSpec | undefined;
+/**
+ * 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 declare function customComponentEntry(component: AppCustomComponentSpec, version: string): ComponentSpec;
+/**
+ * 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 declare function appComponents(app: Pick<AppSpec, 'interface' | 'version'>, catalog: readonly ComponentSpec[]): ComponentSpec[];
+/** What its schema refuses of a node of a surface drawn by it, in sentences; empty when nothing. */
+export declare function customNodeRefused(component: AppCustomComponentSpec, node: Record<string, unknown>): string[];