@datalayer/agent-runtimes 1.3.84 → 1.3.85

package/lib/loop/apps/checks.js

@@ -39,12 +39,13 @@ 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';
@@ -129,6 +130,82 @@ export function ownCodeProblems(app) {
     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. */
@@ -228,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)) {
@@ -380,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') {
@@ -912,6 +1001,19 @@ export function documentShapeProblems(document) {
                 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/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[];

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

@@ -0,0 +1,10 @@
+import type { ReactComponentImplementation } from '@a2ui/react/v0_9';
+export type A2uiComponentContribution = {
+    /** The name a surface gives it (e.g. 'Gauge'). */
+    id: string;
+    /** The application whose developer wrote it, by id. */
+    app: string;
+    /** Its renderer, as A2UI's catalog registers one. */
+    implementation: ReactComponentImplementation;
+};
+export declare const LoopA2uiComponent: import("@datalayer/reactor").ContributionPoint<A2uiComponentContribution>;

package/lib/loop/core/a2uiComponents.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A component an application adds to the A2UI catalog it is drawn with (LOOP
+ * P-17), as a contribution point, re-exported by `loop/core`: the components
+ * its developer wrote, contributed by the application's own plugin, so that
+ * its page, the elements its code shows and its answers draw them — in that
+ * application's workspace, and in no other.
+ *
+ * @module loop/core/a2uiComponents
+ */
+import { defineContributionPoint } from '@datalayer/reactor';
+export const LoopA2uiComponent = defineContributionPoint('loop.a2ui.component');

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

@@ -579,6 +579,7 @@ export type AssistantMenuContribution = {
 };
 export declare const LoopAssistantMenu: import("@datalayer/reactor").ContributionPoint<AssistantMenuContribution>;
 export { LoopCanvasBlock, type CanvasBlockContribution } from './canvasBlocks';
+export { LoopA2uiComponent, type A2uiComponentContribution, } from './a2uiComponents';
 /**
  * The per-example chat extras a host feeds the loop's conversation live.
  *

package/lib/loop/core/index.js

@@ -146,6 +146,9 @@ export const LoopAssistantMenu = defineContributionPoint('loop.assistant.menu');
 // A block the Canvas may place (LOOP C-12), in a module of its own so that
 // the palette is read without the rest of the contracts.
 export { LoopCanvasBlock } from './canvasBlocks';
+// A component an application adds to the catalog it is drawn with (LOOP
+// P-17): the components its developer wrote, for its workspace alone.
+export { LoopA2uiComponent, } from './a2uiComponents';
 export const LoopChatExtras = defineContributionPoint('loop.chat.extras');
 export const LoopOpeningNotebook = defineContributionPoint('loop.notebook.opening');
 export const LoopOpeningDocument = defineContributionPoint('loop.document.opening');

package/lib/loop/embed/AppEmbed.d.ts

@@ -1,5 +1,5 @@
 import type { CSSProperties, JSX, ReactNode } from 'react';
-import type { PluginRef } from '@datalayer/reactor';
+import { type PluginRef } from '@datalayer/reactor';
 import type { AppAccent, AppEmbedMode, AppSpec, AppThemeVariant } from '../../types/agentspecs';
 import type { ResumedThread, ThemeOverrides } from '../../types/chat';
 import type { AssistantCharacter } from '../../chat/assistant/characters';
@@ -24,6 +24,12 @@ export type AppEmbedProps = {
     colorMode?: EmbedColorMode;
     /** The host's face, a CSS font family; the theme's by default. */
     font?: string;
+    /**
+     * The language the visitor reads it in, as BCP 47 tags it (`fr`, `pt-BR`):
+     * its translation into it and the chat's own words (LOOP P-26). The
+     * visitor's browser's by default.
+     */
+    language?: string;
     /**
      * An agent-runtimes server the application's agent runs on. Without one,
      * it runs on a Datalayer runtime, launched with the visitor's Datalayer
@@ -150,6 +156,8 @@ export type AppFloatingProps = {
     host?: AppEmbedHost;
     /** The visit's session, picked up again after a reload (D-13). */
     session?: EmbedSession;
+    /** The language the visitor reads it in (P-26); the browser's by default. */
+    language?: string;
 };
 /**
  * The bubble, the panel and the assistant: `ChatFloating`'s chrome in that
@@ -160,7 +168,7 @@ export type AppFloatingProps = {
  * The workspace tells the chrome what the application is doing and what it
  * last said (`onPresence`, `onSaying`).
  */
-export declare function AppFloating({ app, view, colorMode, themeVariant, themeOverrides, character, serverUrl, instance, embedToken, renderer, host, session, }: AppFloatingProps): JSX.Element;
+export declare function AppFloating({ app, view, colorMode, themeVariant, themeOverrides, character, serverUrl, instance, embedToken, renderer, host, session, language, }: AppFloatingProps): JSX.Element;
 /** The application's theme (`loop` unless it names one), with its (or the host's) accent and face. */
 export declare function EmbedThemed({ accent, colorMode, font, variant, children, style, }: {
     accent: AppAccent;
@@ -170,5 +178,5 @@ export declare function EmbedThemed({ accent, colorMode, font, variant, children
     children: ReactNode;
     style?: CSSProperties;
 }): JSX.Element;
-export declare function AppEmbed({ app, mode, accent, colorMode, font, serverUrl, instance, embedToken, height, ownPortal, plugins, host, resume, }: AppEmbedProps): JSX.Element;
+export declare function AppEmbed({ app, mode, accent, colorMode, font, language, serverUrl, instance, embedToken, height, ownPortal, plugins, host, resume, }: AppEmbedProps): JSX.Element;
 export default AppEmbed;