windows-development-sandbox 1.1.0 → 1.4.0

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

@@ -0,0 +1,40 @@
+import type { Config } from '../../../core/types.js';
+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;
+/**
+ * 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) => {
+    text: string;
+} | {
+    problems: string[];
+};
+export declare class ConfigFile {
+    readonly target: SettingsTarget;
+    readonly file: string;
+    readonly schema: SchemaNode;
+    constructor(target: SettingsTarget, file: string);
+    static user(configPath: string | null): ConfigFile;
+    static project(dir: string): ConfigFile;
+    get isProject(): boolean;
+    get exists(): boolean;
+    text(): string;
+    /** The value written in this file (undefined = not set here). */
+    valueInFile(key: string[]): unknown;
+    /** Your own settings with the built-in defaults filled in (what a sandbox uses without a project file). */
+    userConfig(): Config;
+    /** What is in effect: for your file the merged config, for a project file only what the file sets. */
+    effective(key: string[], config?: Config): unknown;
+    defaultOf(key: string[]): unknown;
+    /**
+     * 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.
+     */
+    set(key: string[], value: unknown): 'unchanged' | 'saved' | {
+        problems: string[];
+    };
+}

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

@@ -0,0 +1,71 @@
+// 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 { 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);
+/**
+ * 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') => {
+    // 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 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) };
+};
+export class ConfigFile {
+    target;
+    file;
+    schema;
+    constructor(target, file) {
+        this.target = target;
+        this.file = file;
+        this.schema = new SchemaNode(target === 'project' ? LocalOverrides : 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') : ''; }
+    /** The value written in this file (undefined = not set here). */
+    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;
+        try {
+            return loadConfig(fs.existsSync(file) ? file : undefined).config;
+        }
+        catch {
+            return loadConfig(undefined).config;
+        }
+    }
+    /** What is in effect: for your file the merged config, for a project file only what the file sets. */
+    effective(key, config = this.userConfig()) {
+        return this.isProject ? this.valueInFile(key) : _.get(config, 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.
+     */
+    set(key, value) {
+        const text = this.text();
+        const next = !this.isProject && value !== undefined && _.isEqual(value, this.defaultOf(key)) ? undefined : value;
+        if (_.isEqual(next, fileValue(text, key)) && (this.isProject || _.isEqual(value, _.get(this.userConfig(), key))))
+            return 'unchanged';
+        const result = editConfigText(text, key, next, this.target);
+        if ('problems' in result)
+            return result;
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        fs.writeFileSync(this.file, result.text, 'utf8');
+        return 'saved';
+    }
+}

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

@@ -0,0 +1,30 @@
+import { App } from '../../tui/index.js';
+import { SchemaNode } from './schema-node.js';
+/** The new value, or undefined when you backed out without changing anything. */
+export type Edited = {
+    value: unknown;
+} | undefined;
+/** A value in one short line, for the right-hand column. */
+export declare const formatValue: (value: unknown, max?: number) => string;
+/** Optional extra knowledge: values to suggest for some settings (the configured agents for defaultHarness). */
+export interface EditorHints {
+    suggestions?: (key: string[]) => string[] | undefined;
+}
+export declare class ValueEditor {
+    private readonly app;
+    private readonly hints;
+    constructor(app: App, hints?: EditorHints);
+    edit(path: string[], key: string[], node: SchemaNode, current: unknown): Promise<Edited>;
+    private pick;
+    private suggest;
+    private json;
+}
+/** 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/editors.js

@@ -0,0 +1,305 @@
+// Editing one value with the screen that fits it: on/off flips, choices are picked from a list, numbers and text are
+// typed and checked as you type, lists and maps get an editor of their own (add, change, remove), and objects (a
+// mapped folder, an agent) open as a small form. JSON is only the last resort for shapes none of these fit.
+import _ from 'lodash';
+import { Text, Theme } from '../../tui/index.js';
+/** A value in one short line, for the right-hand column. */
+export const 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 ...). */
+const 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(', ') + ' }';
+};
+const choiceLabel = (v) => (v === true ? 'On' : v === false ? 'Off' : String(v));
+export class ValueEditor {
+    app;
+    hints;
+    constructor(app, hints = {}) {
+        this.app = app;
+        this.hints = hints;
+    }
+    async edit(path, key, node, current) {
+        const about = node.description ? [node.description] : [];
+        const suggestions = this.hints.suggestions?.(key);
+        if (suggestions?.length && node.type === 'string')
+            return this.suggest(path, key, node, current, suggestions);
+        switch (node.editor) {
+            case 'boolean': return { value: !(current ?? false) };
+            case 'choice': return this.pick(path, node, current, node.choiceValues);
+            case 'union': {
+                const open = node.openOption;
+                const custom = '@custom';
+                const picked = await this.app.choose(path, node.description ?? '', [...node.choiceValues.map((v) => ({ value: v, label: choiceLabel(v) })), ...(open ? [{ value: custom, label: 'Custom ' + open.type + '…', description: 'Type a ' + open.type + ' of your own.' }] : [])], node.choiceValues.includes(current) ? current : open && current !== undefined ? custom : undefined);
+                if (picked === undefined)
+                    return undefined;
+                return picked === custom && open ? this.edit(path, key, open, node.choiceValues.includes(current) ? undefined : current) : { value: picked };
+            }
+            case 'number': {
+                const range = node.min !== undefined || node.max !== undefined ? ' (' + (node.min ?? '…') + ' to ' + (node.max ?? '…') + ')' : '';
+                const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]) + range, about, initial: current === undefined ? '' : String(current), validate: (v) => (v.trim() === '' || !Number.isFinite(Number(v)) ? 'Enter a number.' : node.check(Number(v))) });
+                return typed === undefined ? undefined : { value: Number(typed) };
+            }
+            case 'string': {
+                const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]), about, initial: typeof current === 'string' ? current : '', allowEmpty: node.check('') === true, validate: (v) => node.check(v) });
+                return typed === undefined ? undefined : { value: typed };
+            }
+            case 'choice-list': {
+                const ticked = Array.isArray(current) ? current : [];
+                const picked = await this.app.list({ path, intro: node.description, multi: true, items: node.element.choices.map((v) => ({ value: v, label: String(v), checked: ticked.includes(v) })) });
+                return picked.kind === 'multi' ? { value: picked.values } : undefined;
+            }
+            case 'string-list': return new StringListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
+            case 'string-map': return new MapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
+            case 'object-list': return new ObjectListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
+            case 'object-map': return new ObjectMapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
+            case 'object': return new ObjectEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : node.initial());
+            default: return this.json(path, key, node, current);
+        }
+    }
+    async pick(path, node, current, values) {
+        const picked = await this.app.choose(path, node.description ?? '', values.map((v) => ({ value: v, label: choiceLabel(v) })), current);
+        return picked === undefined ? undefined : { value: picked };
+    }
+    async suggest(path, key, node, current, suggestions) {
+        const other = '@other';
+        const picked = await this.app.choose(path, node.description ?? '', [...suggestions.map((s) => ({ value: s, label: s })), { value: other, label: 'Other…', description: 'Type a name that is not in the list.' }], typeof current === 'string' ? current : undefined);
+        if (picked === undefined)
+            return undefined;
+        if (picked !== other)
+            return { value: picked };
+        const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]), initial: typeof current === 'string' ? current : '', validate: (v) => node.check(v) });
+        return typed === undefined ? undefined : { value: typed };
+    }
+    async json(path, key, node, current) {
+        const typed = await this.app.text({
+            path, label: Text.humanize(key[key.length - 1]) + ' (JSON)', about: node.description ? [node.description] : [], initial: current === undefined ? '' : JSON.stringify(current),
+            validate: (v) => { try {
+                return node.check(JSON.parse(v));
+            }
+            catch {
+                return 'This is not valid JSON.';
+            } },
+        });
+        return typed === undefined ? undefined : { value: JSON.parse(typed) };
+    }
+}
+// ---- collections -----------------------------------------------------------------------------------------------------
+const SAVE = '@save';
+const ADD = '@add';
+/**
+ * The shared shape of the list and map editors: a working copy shown as a list with "Save" and "Add" at the top, Enter
+ * to change an entry, d to delete it. Esc with unsaved changes asks first.
+ */
+class CollectionEditor {
+    app;
+    path;
+    node;
+    editor;
+    value;
+    original;
+    constructor(app, path, node, editor) {
+        this.app = app;
+        this.path = path;
+        this.node = node;
+        this.editor = editor;
+    }
+    noun = 'entry';
+    async run(start) {
+        this.original = structuredClone(start);
+        this.value = structuredClone(start);
+        let focus;
+        for (;;) {
+            const dirty = !_.isEqual(this.value, this.original);
+            const entries = this.entries();
+            const picked = await this.app.list({
+                path: this.path,
+                intro: this.node.description,
+                items: [
+                    { value: SAVE, label: dirty ? Theme.ok(Theme.glyph.ok + ' Save changes') : Theme.muted(Theme.glyph.ok + ' Done (no changes)'), section: 'Actions' },
+                    { value: ADD, label: '+ Add ' + this.noun, section: 'Actions' },
+                    ...entries.map((e) => ({ ...e, section: entries.length + ' ' + this.noun + (entries.length === 1 ? '' : 's') })),
+                ],
+                startAt: focus,
+                actions: [{ key: 'd', label: 'delete' }, ...(this.move ? [{ key: 'u', label: 'move up' }, { key: 'j', label: 'move down' }] : [])],
+                empty: 'No ' + this.noun + 's yet.',
+            });
+            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)
+                return dirty ? { value: this.value } : undefined;
+            if (picked.kind === 'pick' && picked.value === ADD) {
+                await this.add();
+                continue;
+            }
+            const id = picked.kind === 'pick' || picked.kind === 'action' ? picked.value : undefined;
+            if (id === undefined || id === SAVE || id === ADD)
+                continue;
+            focus = id;
+            if (picked.kind === 'pick')
+                await this.open(id);
+            else if (picked.kind === 'action' && picked.key === 'd')
+                this.remove(id);
+            else if (picked.kind === 'action' && this.move)
+                focus = this.move(id, picked.key === 'u' ? -1 : 1) ?? id;
+        }
+    }
+}
+/** A list of strings (project roots, scripts, extra packages ...). */
+class StringListEditor extends CollectionEditor {
+    noun = 'item';
+    entries() { return this.value.map((v, i) => ({ value: String(i), label: v || Theme.muted('(empty)') })); }
+    async ask(initial) {
+        const element = this.node.element;
+        return this.app.text({ path: this.path, label: 'Value', about: this.node.description ? [this.node.description] : [], initial, validate: (v) => element.check(v) });
+    }
+    async add() { const v = await this.ask(''); if (v !== undefined)
+        this.value.push(v); }
+    async open(id) { const v = await this.ask(this.value[Number(id)]); if (v !== undefined)
+        this.value[Number(id)] = v; }
+    remove(id) { this.value.splice(Number(id), 1); }
+    move(id, by) {
+        const from = Number(id);
+        const to = Math.max(0, Math.min(this.value.length - 1, from + by));
+        const [item] = this.value.splice(from, 1);
+        this.value.splice(to, 0, item);
+        return String(to);
+    }
+}
+/** A map of names to simple values (environment variables). */
+class MapEditor extends CollectionEditor {
+    noun = 'variable';
+    entries() { return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: formatValue(v) })); }
+    async add() {
+        const name = await this.app.text({ path: this.path, label: 'Name', about: ['Letters, digits and _ only, e.g. NPM_CONFIG_REGISTRY.'], validate: (v) => (this.value[v] !== undefined ? 'That name is there already.' : /^[A-Za-z_][A-Za-z0-9_]*$/.test(v) ? true : 'Letters, digits and _ only.') });
+        if (name === undefined)
+            return;
+        const edited = await this.editor.edit([...this.path, name], [name], this.node.element, this.node.element.initial());
+        if (edited)
+            this.value[name] = edited.value;
+    }
+    async open(id) {
+        const edited = await this.editor.edit([...this.path, id], [id], this.node.element, this.value[id]);
+        if (edited)
+            this.value[id] = edited.value;
+    }
+    remove(id) { delete this.value[id]; }
+}
+/** A list of objects (mapped folders). */
+class ObjectListEditor extends CollectionEditor {
+    noun = 'entry';
+    entries() { return this.value.map((v, i) => ({ value: String(i), label: summary(v) })); }
+    async add() {
+        const edited = await new ObjectEditor(this.app, [...this.path, 'New'], this.node.element, this.editor).run(this.node.element.initial(), true);
+        if (edited)
+            this.value.push(edited.value);
+    }
+    async open(id) {
+        const edited = await new ObjectEditor(this.app, [...this.path, summary(this.value[Number(id)])], this.node.element, this.editor).run(this.value[Number(id)]);
+        if (edited)
+            this.value[Number(id)] = edited.value;
+    }
+    remove(id) { this.value.splice(Number(id), 1); }
+}
+/** A map of names to objects (agents). */
+class ObjectMapEditor extends CollectionEditor {
+    noun = 'entry';
+    entries() { return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: Theme.muted(summary(v)) })); }
+    async add() {
+        const name = await this.app.text({ path: this.path, label: 'Name', validate: (v) => (this.value[v] !== undefined ? 'That name is there already.' : /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v) ? true : 'Letters, digits, . _ and - only.') });
+        if (name === undefined)
+            return;
+        const edited = await new ObjectEditor(this.app, [...this.path, name], this.node.element, this.editor).run(this.node.element.initial(), true);
+        if (edited)
+            this.value[name] = edited.value;
+    }
+    async open(id) {
+        const edited = await new ObjectEditor(this.app, [...this.path, id], this.node.element, this.editor).run(this.value[id]);
+        if (edited)
+            this.value[id] = edited.value;
+    }
+    remove(id) { delete this.value[id]; }
+}
+/** 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/index.d.ts

@@ -0,0 +1,32 @@
+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;
+}

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

@@ -0,0 +1,136 @@
+// 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);
+    }
+}