windows-development-sandbox 1.4.1 → 1.4.3

package/dist/cli/menu/settings/config-file.d.ts

@@ -3,12 +3,12 @@ import { SchemaNode } from './schema-node.js';
 /** The user's own config, or a project's .sandbox-config.json (a smaller schema; nothing is merged with defaults). */
 export type SettingsTarget = 'user' | 'project';
 /** What the value is in this JSON text (undefined when it is not set there). */
-export declare const fileValue: (text: string, key: string[]) => unknown;
+export declare function fileValue(text: string, key: string[]): unknown;
 /**
  * Applies one change (undefined = remove the line, back to the default) to config text and returns the new text, or
  * the problems that make the result invalid. Pure; ConfigFile writes it.
  */
-export declare const editConfigText: (text: string, key: string[], value: unknown, target?: SettingsTarget) => {
+export declare function editConfigText(text: string, key: string[], value: unknown, target?: SettingsTarget): {
     text: string;
 } | {
     problems: string[];

package/dist/cli/menu/settings/config-file.js

@@ -1,26 +1,35 @@
-// One config file being edited: your own settings, or a project's .sandbox-config.json. One setting is changed at a time
-// through jsonc-parser, so comments and formatting stay, and nothing is written unless the whole file is still valid.
+// One config file being edited: your own settings, or a project's .sandbox-config.json. One setting is changed at a
+// time through jsonc-parser, so comments and formatting stay, and nothing is written unless the whole file is still
+// valid.
 import fs from 'node:fs';
 import path from 'node:path';
 import { applyEdits, modify, parse } from 'jsonc-parser';
 import _ from 'lodash';
-import { DEFAULTS, loadConfig, mergeConfig, userConfigPath } from '../../../core/config.js';
-import { LOCAL_CONFIG_NAME } from '../../../core/local-config.js';
-import { Config as ConfigSchema, describeIssues, LocalOverrides } from '../../../core/schema.js';
+import { DEFAULTS, loadConfig, mergeConfig, userConfigPath } from '../../../core/config/index.js';
+import { LOCAL_CONFIG_NAME } from '../../../core/local-config/index.js';
+import { ConfigSchema, describeIssues, LocalOverridesSchema } from '../../../core/schema/index.js';
 import { SchemaNode } from './schema-node.js';
 /** What the value is in this JSON text (undefined when it is not set there). */
-export const fileValue = (text, key) => _.get(parse(text) ?? {}, key);
+export function fileValue(text, key) {
+    return _.get(parse(text) ?? {}, key);
+}
 /**
  * Applies one change (undefined = remove the line, back to the default) to config text and returns the new text, or
  * the problems that make the result invalid. Pure; ConfigFile writes it.
  */
-export const editConfigText = (text, key, value, target = 'user') => {
+export function editConfigText(text, key, value, target = 'user') {
     // Removing a setting the file does not have changes nothing (jsonc-parser throws on it).
-    const edits = value === undefined && fileValue(text || '{}', key) === undefined ? [] : modify(text || '{}', key, value, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } });
+    const edits = value === undefined && fileValue(text || '{}', key) === undefined
+        ? []
+        : modify(text || '{}', key, value, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } });
     const next = applyEdits(text || '{}', edits);
-    const parsed = target === 'project' ? LocalOverrides.safeParse(parse(next) ?? {}) : ConfigSchema.safeParse(mergeConfig(DEFAULTS, parse(next) ?? {}));
-    return parsed.success ? { text: next.endsWith('\n') ? next : next + '\n' } : { problems: describeIssues(parsed.error) };
-};
+    const parsed = target === 'project'
+        ? LocalOverridesSchema.safeParse(parse(next) ?? {})
+        : ConfigSchema.safeParse(mergeConfig(DEFAULTS, parse(next) ?? {}));
+    return parsed.success
+        ? { text: next.endsWith('\n') ? next : next + '\n' }
+        : { problems: describeIssues(parsed.error) };
+}
 export class ConfigFile {
     target;
     file;
@@ -28,15 +37,27 @@ export class ConfigFile {
     constructor(target, file) {
         this.target = target;
         this.file = file;
-        this.schema = new SchemaNode(target === 'project' ? LocalOverrides : ConfigSchema);
+        this.schema = new SchemaNode(target === 'project' ? LocalOverridesSchema : ConfigSchema);
+    }
+    static user(configPath) {
+        return new ConfigFile('user', configPath ?? userConfigPath());
+    }
+    static project(dir) {
+        return new ConfigFile('project', path.join(dir, LOCAL_CONFIG_NAME));
+    }
+    get isProject() {
+        return this.target === 'project';
+    }
+    get exists() {
+        return fs.existsSync(this.file);
+    }
+    text() {
+        return this.exists ? fs.readFileSync(this.file, 'utf8') : '';
     }
-    static user(configPath) { return new ConfigFile('user', configPath ?? userConfigPath()); }
-    static project(dir) { return new ConfigFile('project', path.join(dir, LOCAL_CONFIG_NAME)); }
-    get isProject() { return this.target === 'project'; }
-    get exists() { return fs.existsSync(this.file); }
-    text() { return this.exists ? fs.readFileSync(this.file, 'utf8') : ''; }
     /** The value written in this file (undefined = not set here). */
-    valueInFile(key) { return fileValue(this.text(), key); }
+    valueInFile(key) {
+        return fileValue(this.text(), key);
+    }
     /** Your own settings with the built-in defaults filled in (what a sandbox uses without a project file). */
     userConfig() {
         const file = this.isProject ? userConfigPath() : this.file;
@@ -51,7 +72,9 @@ export class ConfigFile {
     effective(key, config = this.userConfig()) {
         return this.isProject ? this.valueInFile(key) : _.get(config, key);
     }
-    defaultOf(key) { return _.get(DEFAULTS, key); }
+    defaultOf(key) {
+        return _.get(DEFAULTS, key);
+    }
     /**
      * Saves one setting. In your own file a value equal to the default is removed instead (no line needed). Returns
      * 'unchanged', 'saved', or the problems that stopped it.

package/dist/cli/menu/settings/editor-actions.d.ts

@@ -0,0 +1,2 @@
+export declare const SAVE = "@save";
+export declare const ADD = "@add";

package/dist/cli/menu/settings/editor-actions.js

@@ -0,0 +1,2 @@
+export const SAVE = '@save';
+export const ADD = '@add';

package/dist/cli/menu/settings/format.d.ts

@@ -0,0 +1,5 @@
+/** A value in one short line, for the right-hand column. */
+export declare function formatValue(value: unknown, max?: number): string;
+/** A one-line name for an object in a list (a mapping's folders, an agent's package ...). */
+export declare function summary(value: unknown): string;
+export declare function choiceLabel(v: unknown): string;

package/dist/cli/menu/settings/format.js

@@ -0,0 +1,39 @@
+import _ from 'lodash';
+import { Text, Theme } from '../../tui/index.js';
+/** A value in one short line, for the right-hand column. */
+export function formatValue(value, max = 60) {
+    if (value === undefined)
+        return Theme.muted('not set');
+    if (value === true)
+        return Theme.ok('On');
+    if (value === false)
+        return Theme.muted('Off');
+    if (value === null)
+        return Theme.muted('none');
+    if (typeof value === 'string')
+        return value === '' ? Theme.muted('(empty)') : Text.truncate(value, max);
+    if (typeof value === 'number')
+        return String(value);
+    if (Array.isArray(value))
+        return value.length === 0
+            ? Theme.muted('none')
+            : Text.truncate(value.length + ' · ' + value.map((v) => (typeof v === 'object' ? summary(v) : String(v))).join(', '), max);
+    const keys = Object.keys(value);
+    return keys.length ? Text.truncate(keys.length + ' · ' + keys.join(', '), max) : Theme.muted('none');
+}
+/** A one-line name for an object in a list (a mapping's folders, an agent's package ...). */
+export function summary(value) {
+    if (!_.isPlainObject(value))
+        return String(value);
+    const o = value;
+    const strings = Object.entries(o).filter(([, v]) => typeof v === 'string' && v);
+    if (typeof o.host === 'string' && typeof o.guest === 'string')
+        return o.host + ' → ' + o.guest + (o.readOnly ? ' (read-only)' : '');
+    return (strings
+        .slice(0, 2)
+        .map(([, v]) => v)
+        .join(' · ') || '{ ' + Object.keys(o).join(', ') + ' }');
+}
+export function choiceLabel(v) {
+    return v === true ? 'On' : v === false ? 'Off' : String(v);
+}

package/dist/cli/menu/settings/index.d.ts

@@ -1,32 +1,4 @@
-import { App } from '../../tui/index.js';
-import { ConfigFile } from './config-file.js';
-import type { SchemaNode } from './schema-node.js';
 export { CATEGORIES, nameOf } from './categories.js';
 export { ConfigFile, editConfigText, fileValue, type SettingsTarget } from './config-file.js';
 export { SchemaNode } from './schema-node.js';
-interface Setting {
-    key: string[];
-    node: SchemaNode;
-    category: string;
-    section?: string;
-}
-export type Scope = 'user' | 'project';
-export declare class SettingsEditor {
-    private readonly app;
-    private readonly files;
-    private scope;
-    private readonly dataPath;
-    private readonly editor;
-    /** files: your config and this folder's project file; dataPath: where the apps catalogue looks for installed apps. */
-    constructor(app: App, files: Record<Scope, ConfigFile>, scope?: Scope, dataPath?: string);
-    /** The file the current tab edits. */
-    get file(): ConfigFile;
-    private get title();
-    /** Every editable setting with the category and heading it is shown under. */
-    settings(): Setting[];
-    private item;
-    run(): Promise<void>;
-    private edit;
-    /** Saves (or resets) one setting and returns the notice to show. */
-    private save;
-}
+export { SettingsEditor, type Scope } from './settings-editor.js';

package/dist/cli/menu/settings/index.js

@@ -1,136 +1,4 @@
-// The settings screen: two scopes on tabs, your own settings ("All projects", blue) and this folder's
-// .sandbox-config.json ("This project", purple); Tab switches and keeps your place. Every setting is grouped into
-// categories (sidebar), searchable, with its value in both scopes, its default and description. Enter edits (on/off
-// flips at once), r resets. Edits keep the file's comments and formatting, and nothing is saved unless the whole file
-// stays valid.
-import _ from 'lodash';
-import { NEVER_LOOSER } from '../../../core/local-config.js';
-import { Text, Theme } from '../../tui/index.js';
-import { AppsCatalogue } from '../apps.js';
-import { CATEGORIES, categoryOf, nameOf } from './categories.js';
-import { formatValue, ValueEditor } from './editors.js';
 export { CATEGORIES, nameOf } from './categories.js';
 export { ConfigFile, editConfigText, fileValue } from './config-file.js';
 export { SchemaNode } from './schema-node.js';
-const SCOPES = [
-    { scope: 'user', tab: { label: 'All projects', badge: 'YOURS', paint: Theme.scopeGlobal } },
-    { scope: 'project', tab: { label: 'This project', badge: 'PROJECT', paint: Theme.scopeProject } },
-];
-export class SettingsEditor {
-    app;
-    files;
-    scope;
-    dataPath;
-    editor;
-    /** files: your config and this folder's project file; dataPath: where the apps catalogue looks for installed apps. */
-    constructor(app, files, scope = 'user', dataPath = '') {
-        this.app = app;
-        this.files = files;
-        this.scope = scope;
-        this.dataPath = dataPath;
-        this.editor = new ValueEditor(app, { suggestions: (key) => (['defaultHarness', 'harness'].includes(key.join('.')) ? Object.keys(this.file.userConfig().harnesses) : undefined) });
-    }
-    /** The file the current tab edits. */
-    get file() { return this.files[this.scope]; }
-    get title() { return 'Settings · ' + (this.file.isProject ? 'This project' : 'All projects'); }
-    /** Every editable setting with the category and heading it is shown under. */
-    settings() {
-        return this.file.schema.children().flatMap(([top, node]) => {
-            const category = categoryOf(top);
-            if (!category)
-                return [];
-            const several = category.keys.filter((k) => this.file.schema.child(k)).length > 1;
-            if (!node.isSection)
-                return [{ key: [top], node, category: category.id, section: several && category.id !== 'general' ? nameOf(top) : undefined }];
-            return node.leaves([top]).map(({ key, node: leaf }) => {
-                const heading = [several ? nameOf(top) : undefined, key.length > 2 ? key.slice(1, -1).map(nameOf).join(' › ') : undefined].filter(Boolean).join(' › ');
-                return { key, node: leaf, category: category.id, section: heading || undefined };
-            });
-        });
-    }
-    item(s, config) {
-        const inFile = this.file.valueInFile(s.key);
-        const set = inFile !== undefined;
-        const yours = _.get(config, s.key);
-        const id = s.key.join('.');
-        const project = this.files.project;
-        const inProject = project.schema.leaves().some((l) => l.key.join('.') === id) ? project.valueInFile(s.key) : undefined;
-        const paint = this.file.isProject ? Theme.project : Theme.changed;
-        const value = this.file.isProject && !set ? Theme.muted('all projects: ') + formatValue(yours, 40) : formatValue(this.file.effective(s.key, config));
-        const details = [
-            Theme.muted('Setting       ') + id,
-            Theme.muted('All projects  ') + formatValue(yours, 40) + Theme.muted(this.files.user.valueInFile(s.key) === undefined ? '  (built-in default)' : '  (your file)'),
-            Theme.muted('This project  ') + (inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(formatValue(inProject, 40)))),
-            ...(!this.file.isProject ? [Theme.muted('Default       ') + formatValue(this.file.defaultOf(s.key), 40)] : []),
-            ...(this.file.isProject && NEVER_LOOSER.includes(id) ? [Theme.warn(Theme.glyph.lock + ' A project can only make this stricter than your own setting.')] : []),
-        ];
-        return {
-            value: id,
-            label: Text.humanize(s.key[s.key.length - 1]),
-            hint: set ? paint(Text.strip(value)) + ' ' + paint(Theme.glyph.changed) : value,
-            description: s.node.description,
-            details,
-            section: s.section,
-            category: s.category,
-            keywords: id,
-        };
-    }
-    async run() {
-        let focus;
-        let notice;
-        for (;;) {
-            const config = this.file.userConfig();
-            const settings = this.settings();
-            const categories = CATEGORIES.filter((c) => settings.some((s) => s.category === c.id)).map((c) => ({ id: c.id, label: c.label, description: c.description }));
-            const picked = await this.app.list({
-                path: [this.title],
-                tabs: { items: SCOPES.map((x) => x.tab), active: SCOPES.findIndex((x) => x.scope === this.scope) },
-                status: (this.file.isProject ? Theme.project('●') : Theme.accent('●')) + Theme.muted(' Editing ') + Text.middle(this.file.file, 80) + (this.file.exists ? '' : Theme.muted(' (created when you save)')) + (this.file.isProject ? Theme.muted('  · only what a project may set; needs your approval at the next launch') : ''),
-                items: settings.map((s) => this.item(s, config)),
-                categories,
-                startAt: focus,
-                actions: [{ key: 'r', label: this.file.isProject ? 'remove from project' : 'reset to default' }],
-                notice,
-            });
-            notice = undefined;
-            if (picked.kind === 'back')
-                return;
-            // The other tab, on the same setting when that scope has it.
-            if (picked.kind === 'tab') {
-                this.scope = SCOPES[picked.index].scope;
-                continue;
-            }
-            if (picked.kind !== 'pick' && picked.kind !== 'action')
-                continue;
-            if (picked.value === undefined)
-                continue;
-            focus = picked.value;
-            const setting = settings.find((s) => s.key.join('.') === picked.value);
-            if (picked.kind === 'action')
-                notice = this.save(setting.key, undefined, 'reset');
-            else
-                notice = await this.edit(setting, config);
-        }
-    }
-    async edit(s, config) {
-        // The apps list is picked from the catalogue (by category, with sizes), not typed.
-        if (s.key.join('.') === 'apps.install')
-            return new AppsCatalogue(this.app, this.file, this.dataPath).run();
-        const current = this.file.isProject ? this.file.valueInFile(s.key) ?? _.get(config, s.key) : _.get(config, s.key);
-        const path = [this.title, ...s.key.slice(0, -1).map(nameOf), Text.humanize(s.key[s.key.length - 1])];
-        const edited = await this.editor.edit(path, s.key, s.node, current);
-        return edited ? this.save(s.key, edited.value, 'save') : undefined;
-    }
-    /** Saves (or resets) one setting and returns the notice to show. */
-    save(key, value, how) {
-        const name = key.join('.');
-        const result = this.file.set(key, value);
-        if (result === 'unchanged')
-            return Theme.muted(how === 'reset' ? name + ' is already the default.' : 'Unchanged.');
-        if (typeof result === 'object')
-            return Theme.error(Theme.glyph.cross + ' Not saved: ' + result.problems.join('; '));
-        // The approval is tied to the file's exact contents, so any change makes the project file need approval again.
-        const after = this.file.isProject ? ' The next launch asks you to approve the project file again.' : ' New sandboxes use it.';
-        return Theme.ok(Theme.glyph.ok + ' ' + (how === 'reset' ? 'Reset ' + name + '.' : 'Saved ' + name + '.')) + Theme.muted(after);
-    }
-}
+export { SettingsEditor } from './settings-editor.js';

package/dist/cli/menu/settings/object-editor.d.ts

@@ -0,0 +1,12 @@
+import { type App } from '../../tui/index.js';
+import { type SchemaNode } from './schema-node.js';
+import type { ValueEditor, Edited } from './value-editor.js';
+/** One object as a form: each field with its value, Enter to change it, r to clear an optional one. */
+export declare class ObjectEditor {
+    private readonly app;
+    private readonly path;
+    private readonly node;
+    private readonly editor;
+    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor);
+    run(start: Record<string, unknown>, isNew?: boolean): Promise<Edited>;
+}

package/dist/cli/menu/settings/object-editor.js

@@ -0,0 +1,86 @@
+import _ from 'lodash';
+import { Text, Theme } from '../../tui/index.js';
+import { SAVE } from './editor-actions.js';
+import { formatValue } from './format.js';
+/** One object as a form: each field with its value, Enter to change it, r to clear an optional one. */
+export class ObjectEditor {
+    app;
+    path;
+    node;
+    editor;
+    constructor(app, path, node, editor) {
+        this.app = app;
+        this.path = path;
+        this.node = node;
+        this.editor = editor;
+    }
+    async run(start, isNew = false) {
+        const value = structuredClone(start);
+        let focus;
+        let notice;
+        for (;;) {
+            const dirty = isNew || !_.isEqual(value, start);
+            const problem = this.node.check(value);
+            const fields = this.node.children();
+            const picked = await this.app.list({
+                path: this.path,
+                intro: this.node.description,
+                notice,
+                items: [
+                    {
+                        value: SAVE,
+                        label: problem === true
+                            ? dirty
+                                ? Theme.ok(Theme.glyph.ok + ' Save')
+                                : Theme.muted(Theme.glyph.ok + ' Done (no changes)')
+                            : Theme.warn(Theme.glyph.cross + ' Not complete yet'),
+                        description: problem === true ? undefined : problem,
+                        section: 'Actions',
+                    },
+                    ...fields.map(([name, field]) => ({
+                        value: name,
+                        label: Text.humanize(name),
+                        hint: formatValue(value[name]),
+                        description: field.description,
+                        section: 'Fields',
+                    })),
+                ],
+                startAt: focus,
+                actions: [{ key: 'r', label: 'clear' }],
+            });
+            notice = undefined;
+            if (picked.kind === 'back') {
+                if (!dirty ||
+                    (await this.app.confirm({
+                        path: this.path,
+                        question: 'Discard your changes?',
+                        yes: 'Discard',
+                        no: 'Keep editing',
+                        initial: false,
+                        danger: true,
+                    })))
+                    return undefined;
+                continue;
+            }
+            if (picked.kind === 'pick' && picked.value === SAVE) {
+                if (problem !== true) {
+                    notice = Theme.warn(problem);
+                    continue;
+                }
+                return dirty ? { value } : undefined;
+            }
+            const name = picked.kind === 'pick' || picked.kind === 'action' ? picked.value : undefined;
+            if (!name || name === SAVE)
+                continue;
+            focus = name;
+            const field = this.node.child(name);
+            if (picked.kind === 'action') {
+                delete value[name];
+                continue;
+            }
+            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [name], field, value[name]);
+            if (edited)
+                value[name] = edited.value;
+        }
+    }
+}

package/dist/cli/menu/settings/schema-node.d.ts

@@ -54,7 +54,9 @@ export declare class SchemaNode {
     get choiceValues(): unknown[];
     /** The member of a union that is not a fixed value (a number, a string ...), edited after "Custom...". */
     get openOption(): SchemaNode | undefined;
-    /** What a new entry (in a list or a map) starts as: the default if there is one, otherwise the simplest valid shape. */
+    /**
+     * What a new entry (in a list or a map) starts as: the default if there is one, otherwise the simplest valid shape.
+     */
     initial(): unknown;
     /** Is `value` acceptable here on its own? (The whole file is checked again when it is saved.) */
     check(value: unknown): true | string;

package/dist/cli/menu/settings/schema-node.js

@@ -2,7 +2,9 @@
 const HIDDEN = new Set(['$schema']);
 export class SchemaNode {
     schema;
-    constructor(schema) { this.schema = schema; }
+    constructor(schema) {
+        this.schema = schema;
+    }
     /** The real type under optional() / default() / nullable() / transforms. */
     get inner() {
         let s = this.schema;
@@ -16,16 +18,28 @@ export class SchemaNode {
                 return s;
         }
     }
-    get type() { return this.inner._zod.def.type; }
+    get type() {
+        return this.inner._zod.def.type;
+    }
     /** A group of settings (an object with known fields), opened rather than edited. */
-    get isSection() { return this.type === 'object' && Boolean(this.inner.shape); }
+    get isSection() {
+        return this.type === 'object' && Boolean(this.inner.shape);
+    }
     /** The description, which .partial() / .optional() wrappers may carry on the inner schema instead. */
-    get description() { return this.schema.description ?? this.inner.description; }
-    get min() { return this.inner.minValue ?? undefined; }
-    get max() { return this.inner.maxValue ?? undefined; }
+    get description() {
+        return this.schema.description ?? this.inner.description;
+    }
+    get min() {
+        return this.inner.minValue ?? undefined;
+    }
+    get max() {
+        return this.inner.maxValue ?? undefined;
+    }
     /** The fields of an object, in schema order. */
     children() {
-        return Object.entries(this.inner.shape ?? {}).filter(([name]) => !HIDDEN.has(name)).map(([name, s]) => [name, new SchemaNode(s)]);
+        return Object.entries(this.inner.shape ?? {})
+            .filter(([name]) => !HIDDEN.has(name))
+            .map(([name, s]) => [name, new SchemaNode(s)]);
     }
     child(name) {
         const s = this.inner.shape?.[name];
@@ -33,15 +47,21 @@ export class SchemaNode {
     }
     /** Every setting below this one that has an editor of its own (not a section), with its path. */
     leaves(key = []) {
-        return this.children().flatMap(([name, child]) => (child.isSection ? child.leaves([...key, name]) : [{ key: [...key, name], node: child }]));
+        return this.children().flatMap(([name, child]) => child.isSection ? child.leaves([...key, name]) : [{ key: [...key, name], node: child }]);
     }
     /** Array items, or a map's values. */
     get element() {
         const def = this.inner._zod.def;
-        return def.type === 'array' && def.element ? new SchemaNode(def.element) : def.type === 'record' && def.valueType ? new SchemaNode(def.valueType) : undefined;
+        return def.type === 'array' && def.element
+            ? new SchemaNode(def.element)
+            : def.type === 'record' && def.valueType
+                ? new SchemaNode(def.valueType)
+                : undefined;
     }
     /** Union members. */
-    get options() { return (this.inner._zod.def.options ?? []).map((o) => new SchemaNode(o)); }
+    get options() {
+        return (this.inner._zod.def.options ?? []).map((o) => new SchemaNode(o));
+    }
     /** The values an enum or literal allows. */
     get choices() {
         const def = this.inner._zod.def;
@@ -63,9 +83,19 @@ export class SchemaNode {
             return type;
         const element = this.element;
         if (type === 'array' && element)
-            return element.type === 'string' ? 'string-list' : element.type === 'enum' ? 'choice-list' : element.type === 'object' ? 'object-list' : 'json';
+            return element.type === 'string'
+                ? 'string-list'
+                : element.type === 'enum'
+                    ? 'choice-list'
+                    : element.type === 'object'
+                        ? 'object-list'
+                        : 'json';
         if (type === 'record' && element)
-            return ['string', 'number', 'boolean'].includes(element.type) ? 'string-map' : element.type === 'object' ? 'object-map' : 'json';
+            return ['string', 'number', 'boolean'].includes(element.type)
+                ? 'string-map'
+                : element.type === 'object'
+                    ? 'object-map'
+                    : 'json';
         if (type === 'object')
             return 'object';
         return 'json';
@@ -77,28 +107,45 @@ export class SchemaNode {
         return this.options.flatMap((o) => (o.type === 'boolean' ? [true, false] : o.choices));
     }
     /** The member of a union that is not a fixed value (a number, a string ...), edited after "Custom...". */
-    get openOption() { return this.options.find((o) => !['literal', 'enum', 'boolean'].includes(o.type)); }
-    /** What a new entry (in a list or a map) starts as: the default if there is one, otherwise the simplest valid shape. */
+    get openOption() {
+        return this.options.find((o) => !['literal', 'enum', 'boolean'].includes(o.type));
+    }
+    /**
+     * What a new entry (in a list or a map) starts as: the default if there is one, otherwise the simplest valid shape.
+     */
     initial() {
         const def = this.schema._zod.def;
         if (def.type === 'default')
             return structuredClone(def.defaultValue);
         switch (this.type) {
-            case 'boolean': return false;
-            case 'number': return this.min ?? 0;
-            case 'string': return '';
+            case 'boolean':
+                return false;
+            case 'number':
+                return this.min ?? 0;
+            case 'string':
+                return '';
             case 'enum':
-            case 'literal': return this.choices[0];
-            case 'union': return this.options[0]?.initial();
-            case 'array': return [];
-            case 'record': return {};
-            case 'object': return Object.fromEntries(this.children().filter(([, c]) => !['optional', 'default'].includes(c.schema._zod.def.type)).map(([name, c]) => [name, c.initial()]));
-            default: return null;
+            case 'literal':
+                return this.choices[0];
+            case 'union':
+                return this.options[0]?.initial();
+            case 'array':
+                return [];
+            case 'record':
+                return {};
+            case 'object':
+                return Object.fromEntries(this.children()
+                    .filter(([, c]) => !['optional', 'default'].includes(c.schema._zod.def.type))
+                    .map(([name, c]) => [name, c.initial()]));
+            default:
+                return null;
         }
     }
     /** Is `value` acceptable here on its own? (The whole file is checked again when it is saved.) */
     check(value) {
         const result = this.schema.safeParse(value);
-        return result.success ? true : result.error.issues.map((i) => (i.path.length ? i.path.join('.') + ': ' : '') + i.message).join('; ');
+        return result.success
+            ? true
+            : result.error.issues.map((i) => (i.path.length ? i.path.join('.') + ': ' : '') + i.message).join('; ');
     }
 }

package/dist/cli/menu/settings/settings-editor.d.ts

@@ -0,0 +1,30 @@
+import { type App } from '../../tui/index.js';
+import { type ConfigFile } from './config-file.js';
+import type { SchemaNode } from './schema-node.js';
+interface Setting {
+    key: string[];
+    node: SchemaNode;
+    category: string;
+    section?: string;
+}
+export type Scope = 'user' | 'project';
+export declare class SettingsEditor {
+    private readonly app;
+    private readonly files;
+    private scope;
+    private readonly dataPath;
+    private readonly editor;
+    /** files: your config and this folder's project file; dataPath: where the apps catalogue looks for installed apps. */
+    constructor(app: App, files: Record<Scope, ConfigFile>, scope?: Scope, dataPath?: string);
+    /** The file the current tab edits. */
+    get file(): ConfigFile;
+    private get title();
+    /** Every editable setting with the category and heading it is shown under. */
+    settings(): Setting[];
+    private item;
+    run(): Promise<void>;
+    private edit;
+    /** Saves (or resets) one setting and returns the notice to show. */
+    private save;
+}
+export {};