@swell/cli 2.9.31 → 2.9.33

package/dist/commands/inspect/components.d.ts

@@ -0,0 +1,31 @@
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
+import { ComponentRecord } from '../../lib/inspect/extensions.js';
+interface InspectedComponent extends ComponentRecord {
+    app_id: string;
+    build_file?: unknown;
+}
+export default class Components extends InspectResourceCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        identifier: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        live: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    protected resourceLabel: string;
+    protected resourceLabelSingular: string;
+    protected adminPath: string;
+    protected commandName: string;
+    run(): Promise<void>;
+    protected getListResults(scope: InspectScope): Promise<any[]>;
+    protected metaFor(record: InspectedComponent): string | undefined;
+    protected showDetail(identifier: string, scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private getComponents;
+}
+export {};

package/dist/commands/inspect/components.js

@@ -0,0 +1,110 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { classifyIdentifier, } from '../../lib/apps/inspect-scope.js';
+import { HEX24 } from '../../lib/apps/object-id.js';
+import { resolveAppId } from '../../lib/apps/resolve.js';
+import { componentExtensionId, } from '../../lib/inspect/extensions.js';
+const COMPONENT_FIELDS = 'id, name, file_path, values, build_file, version, date_created, date_updated';
+export default class Components extends InspectResourceCommand {
+    static summary = 'Components with their targets.';
+    static description = `Lists the components of installed apps, grouped by app. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+List output: paste-back key + the targets the component renders in and the extension it belongs to.
+
+Pass an identifier to view a single component config as JSON.
+
+Identifier forms:
+  app.<app>.<name>    — full paste-back key (list column 1)
+  <name>              — requires --app= scope
+  <24-char id>        — any scope
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect components',
+        'swell inspect components --app=my-app',
+        'swell inspect components app.my-app.card',
+        'swell inspect components card --app=my-app',
+        'swell inspect components --live',
+    ];
+    resourceLabel = 'Components';
+    resourceLabelSingular = 'component';
+    adminPath = '/apps/:id/configs';
+    commandName = 'components';
+    async run() {
+        const { args, flags } = await this.parse(Components);
+        await this.runInspect({ args, flags });
+    }
+    async getListResults(scope) {
+        return this.getComponents(scope.appId);
+    }
+    metaFor(record) {
+        const parts = [];
+        const targets = record.values?.targets;
+        const targetIds = Array.isArray(targets)
+            ? targets
+                .map((target) => target?.id)
+                .filter(Boolean)
+            : [];
+        if (targetIds.length > 0) {
+            parts.push(targetIds.join(','));
+        }
+        const extension = componentExtensionId(record.values);
+        if (extension) {
+            parts.push(`extension ${extension}`);
+        }
+        return parts.length > 0 ? parts.join(' · ') : undefined;
+    }
+    async showDetail(identifier, scope, flags) {
+        const kind = classifyIdentifier(identifier);
+        if (kind.kind === 'invalid') {
+            this.error(`Invalid component identifier '${identifier}'. ` +
+                `Expected bare name, full slug (app.<app>.<name>), or 24-char id.`, { exit: 1 });
+        }
+        if (kind.kind === 'name' && !scope.appId) {
+            this.error(`Bare component name '${identifier}' requires --app=<slug> or --app=. to scope. ` +
+                `Alternatively, pass a full slug (app.<app>.<name>) or 24-char id.`, { exit: 1 });
+        }
+        let { appId } = scope;
+        if (kind.kind === 'slug') {
+            appId = HEX24.test(kind.appPart)
+                ? kind.appPart
+                : await resolveAppId(this.api, kind.appPart);
+        }
+        const components = await this.getComponents(appId);
+        const record = components.find((component) => kind.kind === 'id'
+            ? component.id === kind.id
+            : component.name === (kind.kind === 'slug' ? kind.name : identifier));
+        if (!record) {
+            this.throwNotFound(identifier);
+        }
+        this.emitDetail(record, flags);
+    }
+    // Components are configs of the app at its installed version; a
+    // development install has no version
+    async getComponents(appId) {
+        const installed = await this.api.get({ adminPath: '/client/apps' });
+        const apps = (installed?.results ?? []).filter((app) => !appId || app.app_id === appId);
+        const lists = await Promise.all(apps.map(async (app) => {
+            // An app whose configs the store cannot read is left out
+            let results;
+            try {
+                ({ results } = await this.api.getAll({ adminPath: `/apps/${app.app_id}/configs` }, {
+                    query: {
+                        type: 'component',
+                        fields: COMPONENT_FIELDS,
+                        ...(app.version ? { version: app.version } : undefined),
+                    },
+                }));
+            }
+            catch (error) {
+                this.warn(`Components of ${app.app_public_id ?? app.app_id} could not be read: ${error.message}`);
+                return [];
+            }
+            // Shared source under components/ is pushed without a build
+            return (results ?? [])
+                .filter((component) => component.build_file)
+                .map((component) => ({ ...component, app_id: app.app_id }));
+        }));
+        return lists.flat();
+    }
+}

package/dist/commands/inspect/extensions.js

@@ -75,11 +75,12 @@ Identifier forms:
         if (scope.appId) {
             fnQuery.app_id = scope.appId;
         }
+        const unavailableSettings = {};
         const [installedAppsResp, payments, shipments, taxes, functionsResp] = await Promise.all([
             this.api.get({ adminPath: '/client/apps' }),
-            this.fetchSafe('/data/settings/payments'),
-            this.fetchSafe('/data/settings/shipments'),
-            this.fetchSafe('/data/settings/taxes'),
+            this.fetchSafe('payments', unavailableSettings),
+            this.fetchSafe('shipments', unavailableSettings),
+            this.fetchSafe('taxes', unavailableSettings),
             this.api.getAll({ adminPath: '/data/:functions' }, { query: fnQuery }),
         ]);
         const installed = (installedAppsResp?.results ??
@@ -209,6 +210,7 @@ Identifier forms:
                 payments,
                 shipments,
                 taxes,
+                unavailableSettings,
                 functions: state.functions,
                 components: state.components,
             });
@@ -276,11 +278,12 @@ Identifier forms:
                     `Expected bare id or app.<slug>.<extId>.`, { exit: 1 });
             }
         }
+        const unavailableSettings = {};
         const [installedAppsResp, payments, shipments, taxes, functionsResp] = await Promise.all([
             this.api.get({ adminPath: '/client/apps' }, { query: {} }),
-            this.fetchSafe('/data/settings/payments'),
-            this.fetchSafe('/data/settings/shipments'),
-            this.fetchSafe('/data/settings/taxes'),
+            this.fetchSafe('payments', unavailableSettings),
+            this.fetchSafe('shipments', unavailableSettings),
+            this.fetchSafe('taxes', unavailableSettings),
             this.api.getAll({ adminPath: '/data/:functions' }, { query: { app_id: appId, extension: extId } }),
         ]);
         const installed = (installedAppsResp?.results ??
@@ -321,6 +324,7 @@ Identifier forms:
                 payments,
                 shipments,
                 taxes,
+                unavailableSettings,
                 functions: fnsForExtension,
                 components: compsForExtension,
                 localDiff,
@@ -393,12 +397,17 @@ Identifier forms:
         }
         this.log();
     }
-    async fetchSafe(adminPath) {
+    // A settings record that cannot be read is noted, so that its extensions
+    // show the reason rather than look not activated
+    async fetchSafe(record, unavailableSettings) {
         try {
-            const result = await this.api.get({ adminPath });
+            const result = await this.api.get({
+                adminPath: `/data/settings/${record}`,
+            });
             return (result ?? null);
         }
-        catch {
+        catch (error) {
+            unavailableSettings[record] = error.message;
             return null;
         }
     }

package/dist/commands/inspect/frontend.d.ts

@@ -0,0 +1,37 @@
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
+interface InspectedFrontend {
+    [key: string]: unknown;
+    address: string;
+    app_id: string;
+    framework?: string;
+    hosting?: string;
+    installation_id: string;
+}
+export default class Frontend extends InspectResourceCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        identifier: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        live: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    protected resourceLabel: string;
+    protected resourceLabelSingular: string;
+    protected adminPath: string;
+    protected commandName: string;
+    run(): Promise<void>;
+    protected getListResults(scope: InspectScope): Promise<any[]>;
+    protected keyFor(record: InspectedFrontend, appSlugById: Record<string, string>): string;
+    protected metaFor(record: InspectedFrontend): string | undefined;
+    protected showDetail(identifier: string, _scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private getFrontends;
+    private getInstalledApps;
+    private frontendsOf;
+}
+export {};

package/dist/commands/inspect/frontend.js

@@ -0,0 +1,75 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { slugFromInstalledApp } from '../../lib/apps/slug.js';
+import { default as localConfig } from '../../lib/config.js';
+import { getAppFrontendHost } from '../../lib/constants.js';
+export default class Frontend extends InspectResourceCommand {
+    static summary = 'App frontends with hosting and address.';
+    static description = `Lists the frontends of installed apps. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+List output: paste-back key + hosting (managed or self-hosted), framework, and the address the store serves the frontend at.
+
+Pass an identifier to view an app's frontend as JSON: the app's frontend selection (package or self-hosted URL) with its installation and address.
+
+Identifier forms:
+  app.<app>        — full paste-back key (list column 1)
+  <app>            — the app's slug
+  <24-char id>     — the app's id
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect frontend',
+        'swell inspect frontend --app=.',
+        'swell inspect frontend app.my-app',
+        'swell inspect frontend --live',
+    ];
+    resourceLabel = 'Frontends';
+    resourceLabelSingular = 'frontend';
+    adminPath = '/client/apps';
+    commandName = 'frontend';
+    async run() {
+        const { args, flags } = await this.parse(Frontend);
+        await this.runInspect({ args, flags });
+    }
+    async getListResults(scope) {
+        return this.getFrontends(scope.appId);
+    }
+    keyFor(record, appSlugById) {
+        return `app.${appSlugById[record.app_id] ?? record.app_id}`;
+    }
+    metaFor(record) {
+        // A frontend without hosting is self-hosted
+        return [record.hosting || 'self-hosted', record.framework, record.address]
+            .filter(Boolean)
+            .join(' · ');
+    }
+    async showDetail(identifier, _scope, flags) {
+        const app = identifier.replace(/^app\./, '');
+        const installed = await this.getInstalledApps();
+        const match = installed.find((record) => record.app_id === app || slugFromInstalledApp(record) === app);
+        const [frontend] = match ? this.frontendsOf([match]) : [];
+        if (!frontend) {
+            this.throwNotFound(identifier);
+        }
+        this.emitDetail(frontend, flags);
+    }
+    async getFrontends(appId) {
+        const installed = await this.getInstalledApps();
+        return this.frontendsOf(installed.filter((record) => !appId || record.app_id === appId));
+    }
+    async getInstalledApps() {
+        const response = await this.api.get({ adminPath: '/client/apps' });
+        return (response?.results ?? []);
+    }
+    frontendsOf(installed) {
+        const store = localConfig.getDefaultStore();
+        return installed
+            .filter((record) => Object.keys(record.app?.frontend ?? {}).length > 0)
+            .map((record) => ({
+            ...record.app?.frontend,
+            address: getAppFrontendHost(store, record.id),
+            app_id: record.app_id,
+            installation_id: record.id,
+        }));
+    }
+}

package/dist/commands/inspect/functions.d.ts

@@ -1,9 +1,13 @@
 import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
 interface FunctionRecord {
     id?: string;
     kind?: string;
     name?: string;
     enabled?: boolean;
+    auto_disabled?: boolean;
+    attempts_failed?: number;
+    date_first_failed?: string;
     cron?: {
         schedule?: string;
     };
@@ -18,6 +22,7 @@ interface FunctionRecord {
     };
     date_cron_scheduled?: string;
     date_final_attempt?: string;
+    timeout?: number;
     app_id?: string;
 }
 export default class Functions extends InspectResourceCommand {
@@ -37,10 +42,15 @@ export default class Functions extends InspectResourceCommand {
     protected resourceLabelSingular: string;
     protected adminPath: string;
     protected commandName: string;
+    private inactiveApps;
     run(): Promise<void>;
+    protected getListResults(scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<any[]>;
     protected metaFor(r: FunctionRecord): string | undefined;
     protected filterListResults<T>(results: T[]): T[];
-    protected emitDetail(record: FunctionRecord, flags: InspectResourceCommandParsed['flags']): void;
+    protected emitDetail(record: FunctionRecord, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private detailNotes;
+    private lastFailedDelivery;
+    private getInactiveApps;
     /**
      * Model-triggered functions emit `/events:webhooks` rows on each invocation.
      * Route and cron functions do not — pointing the agent at an empty query

package/dist/commands/inspect/functions.js

@@ -1,4 +1,5 @@
 import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { slugFromInstalledApp } from '../../lib/apps/slug.js';
 function deriveTrigger(r) {
     if (r.cron?.schedule) {
         return `cron (${r.cron.schedule})`;
@@ -25,7 +26,7 @@ export default class Functions extends InspectResourceCommand {
     static summary = 'Functions with scheduling and trigger state.';
     static description = `Lists functions across all apps, grouped by app. Pass --app=<slug> or --app=. (current swell.json) to scope.
 
-List output: paste-back key + status (disabled, trigger, next cron run, last failure).
+List output: paste-back key + status (disabled or auto-disabled, failing since and failure count, the date it gets disabled, trigger, next cron run) and whether its app is inactive, which stops all of its functions. The detail view also shows the last failed delivery.
 
 Pass an identifier to view a single record as JSON.
 
@@ -47,15 +48,37 @@ Identifier forms:
     resourceLabelSingular = 'function';
     adminPath = '/data/:functions';
     commandName = 'functions';
+    inactiveApps = [];
     async run() {
         const { args, flags } = await this.parse(Functions);
         await this.runInspect({ args, flags });
     }
+    async getListResults(scope, flags) {
+        const [results, inactiveApps] = await Promise.all([
+            super.getListResults(scope, flags),
+            this.getInactiveApps(),
+        ]);
+        this.inactiveApps = inactiveApps;
+        return results;
+    }
     metaFor(r) {
         const parts = [];
-        if (!r.enabled) {
+        if (this.inactiveApps.some((app) => app.app_id === r.app_id)) {
+            parts.push('app inactive');
+        }
+        if (r.auto_disabled) {
+            parts.push('auto-disabled');
+        }
+        else if (!r.enabled) {
             parts.push('disabled');
         }
+        const failed = r.attempts_failed ?? 0;
+        if (failed > 0) {
+            const since = r.date_first_failed
+                ? `failing since ${r.date_first_failed} · `
+                : '';
+            parts.push(`${since}${failed} fail${failed === 1 ? '' : 's'}`);
+        }
         const trigger = deriveTrigger(r);
         if (trigger) {
             parts.push(trigger);
@@ -63,21 +86,60 @@ Identifier forms:
         if (r.date_cron_scheduled) {
             parts.push(`next ${r.date_cron_scheduled}`);
         }
-        if (r.date_final_attempt) {
-            parts.push(`last fail ${r.date_final_attempt}`);
+        const disableDate = failed > 0 && !r.auto_disabled && getDisableDate(r);
+        if (disableDate) {
+            parts.push(`may disable from ${disableDate}`);
         }
         return parts.length > 0 ? parts.join(' · ') : undefined;
     }
     filterListResults(results) {
         return results.filter((record) => record.kind !== 'workflow');
     }
-    emitDetail(record, flags) {
+    async emitDetail(record, flags) {
         if (record.kind === 'workflow') {
             const workflowName = record.name || record.id;
             const workflowRef = record.id || record.name;
             throw new Error(`Function '${workflowName}' is a workflow. Use "swell inspect workflows ${workflowRef}" instead.`);
         }
-        super.emitDetail(record, flags);
+        super.emitDetail(record, flags, flags.json ? [] : await this.detailNotes(record));
+    }
+    // Notes are best effort: a function shows without those it cannot read
+    async detailNotes(record) {
+        const notes = [];
+        const inactiveApps = await this.getInactiveApps().catch(() => []);
+        const inactiveApp = inactiveApps.find((app) => app.app_id === record.app_id);
+        if (inactiveApp) {
+            notes.push(`App ${slugFromInstalledApp(inactiveApp) ?? inactiveApp.app_id} is inactive: none of its functions run.`);
+        }
+        if (record.id &&
+            (record.auto_disabled || (record.attempts_failed ?? 0) > 0)) {
+            const failure = await this.lastFailedDelivery(record.id).catch(() => { });
+            if (failure) {
+                notes.push(`Last failed delivery: ${failure}`);
+            }
+        }
+        return notes;
+    }
+    async lastFailedDelivery(functionId) {
+        const response = await this.api.get({ adminPath: '/data/events:webhooks' }, { query: { function_id: functionId, sort: 'date_sent desc', limit: 1 } });
+        const delivery = response?.results?.[0];
+        if (!delivery) {
+            return undefined;
+        }
+        const { date_sent: dateSent, response: answer, status } = delivery;
+        if (status >= 200 && status < 300) {
+            return undefined;
+        }
+        const message = answer?.error?.message ??
+            answer?.message ??
+            (typeof answer === 'string' ? answer : undefined);
+        return [dateSent, status ?? 'no response', message]
+            .filter(Boolean)
+            .join(' · ');
+    }
+    async getInactiveApps() {
+        const response = await this.api.get({ adminPath: '/client/apps' });
+        return (response?.results ?? []).filter((app) => app.active === false);
     }
     /**
      * Model-triggered functions emit `/events:webhooks` rows on each invocation.
@@ -96,3 +158,24 @@ Identifier forms:
         return lines;
     }
 }
+// A function with a timeout over this is switched off sooner
+const LONG_TIMEOUT_MS = 10000;
+const LONG_TIMEOUT_DISABLE_DAYS = 2;
+/**
+ * When a failing function is switched off if it keeps failing: at its final
+ * attempt, or two days after its first failure when its timeout is long. A
+ * 404 switches it off at once.
+ * @param r The function
+ * @returns The date, as the API gives dates
+ */
+function getDisableDate(r) {
+    if ((r.timeout ?? 0) > LONG_TIMEOUT_MS) {
+        if (!r.date_first_failed) {
+            return undefined;
+        }
+        const date = new Date(r.date_first_failed);
+        date.setUTCDate(date.getUTCDate() + LONG_TIMEOUT_DISABLE_DAYS);
+        return date.toISOString();
+    }
+    return r.date_final_attempt;
+}

package/dist/commands/inspect/index.js

@@ -11,6 +11,8 @@ export default class Inspect extends Command {
         'swell inspect workflow-runs --workflow app.my-app.run-import --status active',
         'swell inspect notifications com.orders.receipt.v2',
         'swell inspect settings app.my-app',
+        'swell inspect components --app=.',
+        'swell inspect frontend app.my-app',
     ];
     async run() {
         this.log('Run "swell inspect --help" to see available subcommands.');

package/dist/commands/schema.js

@@ -6,6 +6,7 @@ import * as fs from 'node:fs/promises';
 import parseJson from 'parse-json';
 import { bundleFunction } from '../lib/bundle.js';
 import { SCHEMAS_BASE_URL } from '../lib/constants.js';
+import { getFunctionDeclarations } from '../lib/function-declarations.js';
 import { analyzeFunctionSource, getFunctionTriggers, hasKindDiagnostic, workflowStaticConfigError, } from '../lib/function-source-analysis.js';
 import { SwellCommand } from '../swell-command.js';
 const SCHEMA_DEFINITIONS = Object.freeze({
@@ -164,6 +165,10 @@ export default class Schema extends SwellCommand {
                 break;
             }
             case 'dts': {
+                if (type === 'function') {
+                    output = await getFunctionDeclarations(process.cwd());
+                    break;
+                }
                 const dtsUrl = this.getTypeScriptDeclarationsUrl(type);
                 const response = await fetch(dtsUrl);
                 if (!response.ok) {

package/dist/help/custom-help.js

@@ -280,7 +280,11 @@ export default class CustomHelp extends Help {
             const value = ('helpValue' in flag && flag.helpValue) ||
                 ('options' in flag && flag.options ? 'option' : 'value');
             const suffix = flag.type === 'boolean' ? '' : `=<${value}>`;
-            return [name, `${shortChar}--${name}${suffix}`];
+            const negatable = flag.type === 'boolean' && flag.allowNo;
+            return [
+                name,
+                `${shortChar}--${negatable ? '[no-]' : ''}${name}${suffix}`,
+            ];
         }));
         const flagWidth = Math.max(30, ...[...flagLabels.values()].map((label) => label.length));
         for (const [name, flag] of flagEntries) {

package/dist/inspect-resource-command.d.ts

@@ -87,7 +87,7 @@ export declare abstract class InspectResourceCommand extends SwellCommand {
      * `--json` is the machine-readable contract — hints belong in the same
      * stream as the human-facing output and are simply omitted there.
      */
-    protected emitDetail(record: any, flags: InspectResourceCommandParsed['flags']): void;
+    protected emitDetail(record: any, flags: InspectResourceCommandParsed['flags'], notes?: string[]): Promise<void> | void;
     private lookupByAppAndName;
     private printPreamble;
     protected throwNotFound(identifier: string): never;

package/dist/inspect-resource-command.js

@@ -189,7 +189,7 @@ export class InspectResourceCommand extends SwellCommand {
         if (!record) {
             this.throwNotFound(identifier);
         }
-        this.emitDetail(record, flags);
+        await this.emitDetail(record, flags);
     }
     /**
      * Per-subclass detail-mode hints. Return runnable commands pointing to
@@ -208,11 +208,17 @@ export class InspectResourceCommand extends SwellCommand {
      * `--json` is the machine-readable contract — hints belong in the same
      * stream as the human-facing output and are simply omitted there.
      */
-    emitDetail(record, flags) {
+    emitDetail(record, flags, notes = []) {
         this.log(JSON.stringify(record, null, 2));
         if (flags.json) {
             return;
         }
+        if (notes.length > 0) {
+            this.log();
+            for (const note of notes) {
+                this.log(note);
+            }
+        }
         const lines = this.hints(record);
         if (lines.length === 0) {
             return;

package/dist/lib/api-errors.d.ts

@@ -0,0 +1 @@
+export declare function errorReasons(errors: unknown, path?: string[]): string[];

package/dist/lib/api-errors.js

@@ -0,0 +1,28 @@
+// Every reason an API error answer gives, each with the path of the field it
+// is about: errors come as { field: { message } }, nested, as strings or as
+// { error } without a field
+export function errorReasons(errors, path = []) {
+    if (typeof errors === 'string') {
+        return [formatReason(path, errors)];
+    }
+    if (Array.isArray(errors)) {
+        return errors.flatMap((item) => errorReasons(item, path));
+    }
+    if (!errors || typeof errors !== 'object') {
+        return [];
+    }
+    const { message, ...fields } = errors;
+    if (typeof message === 'string') {
+        return [formatReason(path, message)];
+    }
+    return Object.entries(fields).flatMap(([key, value]) => 
+    // An error's code names its kind, not a reason
+    key === 'code' && typeof value === 'string'
+        ? []
+        : // Developers know an app's private_id as the id in swell.json
+            errorReasons(value, [...path, key === 'private_id' ? 'id' : key]));
+}
+function formatReason(path, message) {
+    const fieldPath = path.filter((key) => key !== 'error').join('.');
+    return fieldPath ? `${fieldPath}: ${message}` : message;
+}

package/dist/lib/apps/actions.d.ts

@@ -0,0 +1,45 @@
+type Values = Record<string, any>;
+export type ActionSource = 'bulk' | 'field' | 'list' | 'record' | 'settings';
+/** An app function action, with what the dashboard sends to run it */
+export interface DeclaredAction {
+    function: string;
+    id: string;
+    modal?: Values;
+    /** The query of the view whose records a bulk action runs on */
+    query?: Values;
+    /** The name of the settings config, for a settings action or action field */
+    settings?: string;
+    source: ActionSource;
+    view?: string;
+}
+/**
+ * The function actions a content config declares.
+ *
+ * @param values the values of the content config
+ * @returns the actions
+ */
+export declare function getContentActions(values: Values): DeclaredAction[];
+/**
+ * The function actions a settings config declares.
+ *
+ * @param values the values of the settings config
+ * @param settings the name of the settings config
+ * @returns the actions
+ */
+export declare function getSettingsActions(values: Values, settings: string): DeclaredAction[];
+/**
+ * The ids of the fields of an action's modal, as the platform finds them to
+ * pass on only their values.
+ *
+ * @param modal the modal of the action
+ * @returns the field ids
+ */
+export declare function getModalFieldIds(modal: Values): string[];
+/**
+ * A function name as the platform compares an action's `function` with it.
+ *
+ * @param name a function name
+ * @returns the name in the form the platform compares
+ */
+export declare function functionSlug(name: string): string;
+export {};