windows-development-sandbox 1.5.0 → 1.9.0

package/dist/cli/menu/pages/settings-page.js

@@ -1,116 +1,86 @@
-// Tab 5: every setting, for all projects or just this project (two scopes), grouped into categories on the left and
-// searchable, with each value, its default and its description. Changes are staged in the Draft (marked *) and
-// written with Ctrl+S; Enter edits, r resets to the default, z undoes an unsaved change.
+// Section 5: every setting, for all projects or just this project (two scopes), grouped into categories on the left and
+// searchable, with each value, its default and its description. The rows (which settings, their values, secrets as
+// ***) are the settings feature's; this page lays the unsaved changes over them: changes are staged in the Draft
+// (marked *) and written with Ctrl+S; Enter edits, r resets to the default, z undoes an unsaved change.
 import _ from 'lodash';
-import { NEVER_LOOSER } from '../../../core/local-config/index.js';
+import { CATEGORIES, labelOf, nameOf, settingRow, settingsOf, } from '../../../app/features/settings/index.js';
+import { valueText } from '../../../app/kernel/index.js';
 import { errMsg } from '../../../core/util/index.js';
 import { Text, Theme, } from '../../tui/index.js';
-import { CATEGORIES, categoryOf, nameOf } from '../settings/categories.js';
-import { formatValue } from '../settings/format.js';
+import { dataFolderRow, DataFolderFlow } from '../data-folder.js';
+import { EXPORT_SETTINGS, IMPORT_SETTINGS, ShareSettingsFlow, shareSettingsRows } from '../share-settings.js';
+import { VpnLoginFlow, vpnLoginRow, VPN_LOGIN } from '../vpn-login.js';
 import { ValueEditor } from '../settings/value-editor.js';
 import { SCOPES, scopeStatus } from './scopes.js';
 import { ListPage } from './list-page.js';
-/** Every editable setting with the category and heading it is shown under. */
-export function settingsOf(file) {
-    return file.schema.children().flatMap(([top, node]) => {
-        const category = categoryOf(top);
-        if (!category)
-            return [];
-        const several = category.keys.filter((k) => 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 };
-        });
-    });
-}
-/** What the file will say for a setting once the staged changes are saved (undefined = not set there). */
-function written(file, draft, key) {
-    return draft.has(file, key) ? draft.value(file, key) : file.valueInFile(key);
-}
-/** What is in effect for a setting once the staged changes are saved. */
-function effective(file, draft, key, config) {
-    if (file.isProject)
-        return written(file, draft, key);
-    return draft.has(file, key) ? (draft.value(file, key) ?? file.defaultOf(key)) : _.get(config, key);
+export { settingsOf };
+/** The files with the menu's unsaved changes laid over them. */
+function draftSource(draft) {
+    const written = (file, key) => draft.has(file, key) ? draft.value(file, key) : file.valueInFile(key);
+    return {
+        written,
+        effective: (file, key, config) => file.isProject
+            ? written(file, key)
+            : draft.has(file, key)
+                ? (draft.value(file, key) ?? file.defaultOf(key))
+                : _.get(config, key),
+    };
 }
-/** Plain words for settings whose key is jargon (the key itself stays in the details pane). */
-const LABELS = {
-    mappings: 'Extra folders from this PC',
-    'sandbox.vGpu': 'Graphics acceleration',
-    'sandbox.headless': 'Hide the sandbox window',
-    'sandbox.memoryMb': 'Memory (MB)',
-    'sandbox.pageFileMb': 'Swap file (MB)',
-    'network.dns': 'DNS servers',
-    'projects.wsbShare': 'Add folders while the sandbox runs',
-    'projects.all': 'Map all known projects at start',
-    'claudeProfile.hostDir': 'Claude folder on this PC',
-    'claudeProfile.globalStateFile': 'Claude state file on this PC',
-};
-function labelOf(key) {
-    return LABELS[key.join('.')] ?? Text.humanize(key[key.length - 1]);
+/** A value of a row in one short line, painted like every value in the menu. */
+function shown(row, value, max = 60) {
+    const v = valueText(value, row.field, max);
+    return v.tone === 'ok' ? Theme.ok(v.text) : v.tone === 'muted' ? Theme.muted(v.text) : v.text;
 }
-function item(s, files, scope, draft, config) {
-    const file = files[scope];
-    const id = s.key.join('.');
-    const set = written(file, draft, s.key) !== undefined;
-    const unsaved = draft.has(file, s.key);
-    const yours = effective(files.user, draft, s.key, config);
-    const project = files.project;
-    const inProject = project.schema.leaves().some((l) => l.key.join('.') === id)
-        ? written(project, draft, s.key)
-        : undefined;
+function item(row, file, draft) {
+    const unsaved = draft.has(file, row.key);
     const paint = file.isProject ? Theme.project : Theme.changed;
-    const value = file.isProject && !set
-        ? Theme.muted('all projects: ') + formatValue(yours, 40)
-        : formatValue(effective(file, draft, s.key, config));
+    const value = file.isProject && !row.set ? Theme.muted('all projects: ') + shown(row, row.yours, 40) : shown(row, row.value);
     const details = [
-        Theme.muted('Setting       ') + id,
+        Theme.muted('Setting       ') + row.id,
         Theme.muted('All projects  ') +
-            formatValue(yours, 40) +
-            Theme.muted(written(files.user, draft, s.key) === undefined ? '  (built-in default)' : '  (your file)'),
+            shown(row, row.yours, 40) +
+            Theme.muted(row.yoursSet ? '  (your file)' : '  (built-in default)'),
         Theme.muted('This project  ') +
-            (inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(formatValue(inProject, 40)))),
-        ...(!file.isProject ? [Theme.muted('Default       ') + formatValue(file.defaultOf(s.key), 40)] : []),
+            (row.inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(shown(row, row.inProject, 40)))),
+        ...(!file.isProject ? [Theme.muted('Default       ') + shown(row, row.default, 40)] : []),
         ...(unsaved ? [Theme.warn('Unsaved: Ctrl+S saves, z undoes this change.')] : []),
-        ...(file.isProject && NEVER_LOOSER.includes(id)
+        ...(file.isProject && row.locked
             ? [Theme.warn(Theme.glyph.lock + ' A project can only make this stricter than your own setting.')]
             : []),
     ];
     return {
-        value: id,
-        label: labelOf(s.key),
+        value: row.id,
+        label: row.label,
         hint: unsaved
             ? paint(Text.strip(value)) + ' ' + Theme.warn('*')
-            : set
+            : row.set
                 ? paint(Text.strip(value)) + ' ' + paint(Theme.glyph.changed)
                 : value,
-        description: s.node.description,
+        description: row.field.help,
         details,
-        section: s.section,
-        category: s.category,
-        keywords: id,
-        flip: s.node.editor === 'boolean',
+        section: row.section,
+        category: row.category,
+        keywords: row.id,
+        flip: row.field.kind === 'boolean',
     };
 }
-/** The list for the settings tab. Pure (reads the files it is given). */
-export function settingsOptions(files, scope, draft) {
+/** What a setting is now for editing: the staged value, else the file's (a project), else what is in effect. */
+function current(file, draft, key, config) {
+    const source = draftSource(draft);
+    return file.isProject ? (source.written(file, key) ?? _.get(config, key)) : source.effective(file, key, config);
+}
+/** The row in General that opens the data folder flow (your own settings only). */
+export const DATA_FOLDER = '@data-folder';
+/** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */
+export function settingsOptions(files, scope, draft, extra = []) {
     const file = files[scope];
-    const config = file.userConfig();
-    const settings = settingsOf(file);
+    const config = files.user.userConfig();
+    // The Data folder row stands in for the storage folder setting (changing it moves the data, which is asked about).
+    const hideRoot = !file.isProject && extra.some((e) => e.value === DATA_FOLDER);
+    const settings = settingsOf(file).filter((s) => !(hideRoot && s.key.join('.') === 'storage.root'));
+    const rows = settings.map((s) => settingRow(s, files, scope, draftSource(draft), config));
+    const set = new Set(rows.filter((r) => r.set).map((r) => r.id));
+    const unsaved = new Set(rows.filter((r) => draft.has(file, r.key)).map((r) => r.id));
     const categories = CATEGORIES.filter((c) => settings.some((s) => s.category === c.id)).map((c) => ({
         id: c.id,
         label: c.label,
@@ -120,27 +90,32 @@ export function settingsOptions(files, scope, draft) {
         path: [],
         status: scopeStatus(file),
         tabs: { items: SCOPES.map((x) => x.tab), active: SCOPES.findIndex((x) => x.scope === scope) },
-        items: settings.map((s) => item(s, files, scope, draft, config)),
+        items: [...rows.map((r) => item(r, file, draft)), ...(file.isProject ? [] : extra)],
         categories,
         actions: [
-            { key: 'r', label: file.isProject ? 'remove' : 'reset' },
-            { key: 'z', label: 'undo' },
+            { key: 'r', label: file.isProject ? 'remove' : 'reset to default', applies: (id) => set.has(id) },
+            { key: 'z', label: 'undo', applies: (id) => unsaved.has(id) },
         ],
-        enterLabel: 'edit',
-        escapeLabel: 'quit',
+        enterLabel: (_category, id) => id === DATA_FOLDER || id === VPN_LOGIN
+            ? 'change'
+            : id === EXPORT_SETTINGS || id === IMPORT_SETTINGS
+                ? 'open'
+                : 'edit',
     };
 }
 export class SettingsPage extends ListPage {
     files;
     draft;
+    ctx;
     label = 'Settings';
     stages = true;
     scope = 'user';
     editor;
-    constructor(app, files, draft) {
+    constructor(app, files, draft, ctx) {
         super(app);
         this.files = files;
         this.draft = draft;
+        this.ctx = ctx;
         this.editor = new ValueEditor(app, {
             suggestions: (key) => ['defaultHarness', 'harness'].includes(key.join('.'))
                 ? Object.keys(this.files.user.userConfig().harnesses)
@@ -154,7 +129,12 @@ export class SettingsPage extends ListPage {
         return Promise.resolve();
     }
     options() {
-        return settingsOptions(this.files, this.scope, this.draft);
+        const row = dataFolderRow(this.ctx);
+        return settingsOptions(this.files, this.scope, this.draft, [
+            { value: DATA_FOLDER, category: 'general', ...row },
+            { value: VPN_LOGIN, category: 'network', ...vpnLoginRow(this.ctx) },
+            ...shareSettingsRows().map((r) => ({ ...r, category: 'general' })),
+        ]);
     }
     /** Stages a value; your own file never keeps a line that only repeats the default. */
     stage(key, value) {
@@ -176,6 +156,24 @@ export class SettingsPage extends ListPage {
             return {};
         if (result.value === undefined)
             return {};
+        if (result.value === DATA_FOLDER) {
+            if (result.kind !== 'pick')
+                return {};
+            const exit = await new DataFolderFlow(this.app, this.ctx).run();
+            return exit ? { exit } : { reload: true };
+        }
+        if (result.value === EXPORT_SETTINGS || result.value === IMPORT_SETTINGS) {
+            if (result.kind !== 'pick')
+                return {};
+            const flow = new ShareSettingsFlow(this.app, this.ctx);
+            const notice = await (result.value === EXPORT_SETTINGS ? flow.export() : flow.import());
+            return { reload: true, notice };
+        }
+        if (result.value === VPN_LOGIN) {
+            if (result.kind !== 'pick')
+                return {};
+            return { reload: true, notice: await new VpnLoginFlow(this.app, this.ctx).run() };
+        }
         const setting = settingsOf(this.file).find((s) => s.key.join('.') === result.value);
         if (!setting)
             return {};
@@ -187,15 +185,10 @@ export class SettingsPage extends ListPage {
             this.stage(setting.key, undefined);
             return {};
         }
-        if (result.value === 'apps.install')
-            return { notice: Theme.muted('Choose apps on the Apps tab (press 4); the list is picked there, not typed.') };
         try {
-            const config = this.file.userConfig();
-            const current = this.file.isProject
-                ? (written(this.file, this.draft, setting.key) ?? _.get(config, setting.key))
-                : effective(this.file, this.draft, setting.key, config);
+            const now = current(this.file, this.draft, setting.key, this.file.userConfig());
             const path = ['Settings', ...setting.key.slice(0, -1).map(nameOf), labelOf(setting.key)];
-            const edited = await this.editor.edit(path, setting.key, setting.node, current);
+            const edited = await this.editor.edit(path, setting.key, setting.node, now);
             if (edited)
                 this.stage(setting.key, edited.value);
         }

package/dist/cli/menu/render-view.d.ts

@@ -0,0 +1,28 @@
+import type { Action, Page } from '../../app/kernel/index.js';
+import { type ListAction, type ListItem, type ListResult } from '../tui/index.js';
+/** The row that stands for the empty state. */
+export declare const EMPTY_ROW = "@empty";
+/** What the list returned, as the page means it. */
+export type Chosen = {
+    readonly kind: 'refresh';
+} | {
+    readonly kind: 'action';
+    readonly action: Action;
+};
+export interface MenuView {
+    readonly items: ListItem<string>[];
+    readonly actions: ListAction<string>[];
+    /** What Enter does on a row ("" = it only shows information). */
+    enterLabel(category: string | undefined, id: string | undefined): string;
+    resolve(result: ListResult<string>): Chosen | undefined;
+}
+export interface MenuViewOptions {
+    /** Every row goes in this category (a view that is one category of a page). */
+    readonly category?: string;
+    /** Put before every row's value, so the rows cannot clash with the page's own rows. */
+    readonly prefix?: string;
+    /** Offer l to load the data again (default: yes). */
+    readonly refresh?: boolean;
+}
+/** The menu's rows, keys and Enter labels for a page. */
+export declare function menuView(page: Page, o?: MenuViewOptions): MenuView;

package/dist/cli/menu/render-view.js

@@ -0,0 +1,112 @@
+import { pageHasContent } from '../../app/kernel/index.js';
+import { safeText } from '../../core/util/index.js';
+import { Theme } from '../tui/index.js';
+/** The row that stands for the empty state. */
+export const EMPTY_ROW = '@empty';
+const FACT = 'fact:';
+const ACTION = 'action:';
+const REFRESH_KEY = 'l';
+const PAINT = {
+    ok: Theme.ok,
+    warn: Theme.warn,
+    danger: Theme.error,
+    muted: Theme.muted,
+    accent: Theme.accent,
+};
+const paint = (text, tone) => text === undefined ? undefined : tone ? PAINT[tone](safeText(text)) : safeText(text);
+/** The menu's rows, keys and Enter labels for a page. */
+export function menuView(page, o = {}) {
+    const category = o.category ? { category: o.category } : {};
+    const prefix = o.prefix ?? '';
+    const items = [];
+    /** The action Enter runs, by row. */
+    const enter = new Map();
+    /** Key actions that apply to one row, by row. */
+    const keyed = new Map();
+    /** Key actions that apply everywhere. */
+    const everywhere = [...(page.actions ?? [])];
+    if (!pageHasContent(page) && page.empty) {
+        const e = page.empty;
+        items.push({
+            value: prefix + EMPTY_ROW,
+            label: e.action?.label ?? e.text,
+            section: e.title,
+            description: e.text,
+            ...category,
+        });
+        if (e.action)
+            enter.set(prefix + EMPTY_ROW, e.action);
+    }
+    for (const section of page.sections) {
+        const heading = section.title ?? page.title;
+        for (const f of section.facts ?? [])
+            items.push({
+                value: prefix + FACT + f.id,
+                label: f.label,
+                hint: paint(f.value, f.tone),
+                description: f.description,
+                details: f.details?.map(safeText),
+                section: heading,
+                ...category,
+            });
+        for (const item of section.items ?? []) {
+            const id = prefix + item.id;
+            items.push({
+                value: id,
+                label: safeText(item.label),
+                hint: paint(item.hint, item.tone),
+                description: item.description,
+                details: item.details?.map(safeText),
+                section: item.group ?? heading,
+                keywords: item.keywords,
+                ...(item.disabled ? { disabled: item.disabled } : {}),
+                ...category,
+            });
+            if (item.primary && !item.disabled)
+                enter.set(id, item.primary);
+            if (item.actions?.length)
+                keyed.set(id, [...item.actions]);
+        }
+        (section.actions ?? []).forEach((a, i) => {
+            const id = prefix + ACTION + section.id + ':' + i;
+            items.push({ value: id, label: a.label, hint: '', description: a.description, section: 'Actions', ...category });
+            enter.set(id, a);
+            everywhere.push(a);
+        });
+    }
+    const keys = [];
+    const addKey = (a, applies) => {
+        if (!a.key || keys.some((k) => k.key === a.key && k.label === (a.verb ?? a.label)))
+            return;
+        keys.push({ key: a.key, label: a.verb ?? a.label, importance: a.importance ?? 2, ...(applies ? { applies } : {}) });
+    };
+    for (const a of everywhere)
+        addKey(a);
+    for (const list of keyed.values())
+        for (const a of list)
+            addKey(a, (row) => keyed.get(row)?.some((x) => x.key === a.key) ?? false);
+    if (o.refresh !== false)
+        keys.push({ key: REFRESH_KEY, label: 'refresh', importance: 3 });
+    return {
+        items,
+        actions: keys,
+        enterLabel: (_category, id) => {
+            const a = id === undefined ? undefined : enter.get(id);
+            return a ? (a.verb ?? a.label.toLowerCase()) : '';
+        },
+        resolve: (result) => {
+            if (result.kind === 'pick') {
+                const a = enter.get(result.value);
+                return a ? { kind: 'action', action: a } : undefined;
+            }
+            if (result.kind !== 'action')
+                return undefined;
+            if (result.key === REFRESH_KEY && o.refresh !== false)
+                return { kind: 'refresh' };
+            const own = result.value === undefined ? undefined : keyed.get(result.value)?.find((a) => a.key === result.key);
+            const shared = everywhere.find((a) => a.key === result.key);
+            const a = own ?? shared;
+            return a ? { kind: 'action', action: a } : undefined;
+        },
+    };
+}

package/dist/cli/menu/settings/ask-path.d.ts

@@ -0,0 +1,14 @@
+import type { PathKind } from '../../../app/kernel/index.js';
+import type { App } from '../../tui/index.js';
+export interface AskPathOptions {
+    readonly path: string[];
+    readonly title: string;
+    readonly about?: string[];
+    readonly kind: PathKind;
+    readonly initial?: string;
+    readonly literals?: readonly string[];
+    /** true = fine, a string = what is wrong (shown under the path). */
+    readonly validate?: (path: string) => true | string;
+}
+/** Picks a folder or file in the path picker; typing a path (or an allowed word) still works. */
+export declare function askPath(app: App, o: AskPathOptions): Promise<string | undefined>;

package/dist/cli/menu/settings/ask-path.js

@@ -0,0 +1,14 @@
+/** Picks a folder or file in the path picker; typing a path (or an allowed word) still works. */
+export function askPath(app, o) {
+    return app.pickPath({
+        path: o.path,
+        title: o.title,
+        about: o.about,
+        initial: o.initial,
+        files: o.kind === 'file',
+        use: o.kind === 'file' ? 'use this file' : 'use this folder',
+        literals: o.literals,
+        relative: true,
+        validate: o.validate,
+    });
+}

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

@@ -1,5 +1,5 @@
 import { type App, type ListItem } from '../../../tui/index.js';
-import { type SchemaNode } from '../schema-node.js';
+import type { SchemaNode } from '../../../../app/kernel/index.js';
 import type { ValueEditor, Edited } from '../value-editor.js';
 /**
  * The shared shape of the list and map editors: a working copy shown as a list with "Add" at the top, Enter to change
@@ -10,14 +10,20 @@ export declare abstract class CollectionEditor<C> {
     protected readonly path: string[];
     protected readonly node: SchemaNode;
     protected readonly editor: ValueEditor;
+    /** The setting's key (a list's own, without positions): what the entries are is read from it. */
+    protected readonly key: string[];
     protected value: C;
     private original;
-    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor);
+    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor, 
+    /** The setting's key (a list's own, without positions): what the entries are is read from it. */
+    key?: string[]);
     protected abstract entries(): ListItem<string>[];
     protected abstract add(): Promise<void>;
     protected abstract open(id: string): Promise<void>;
     protected abstract remove(id: string): void;
     protected move?(id: string, by: number): string | undefined;
     protected noun: string;
+    /** What leaving with changes does, shown under the list (settings: they wait for Ctrl+S). */
+    protected keepNote: string;
     run(start: C): Promise<Edited>;
 }

package/dist/cli/menu/settings/collections/collection-editor.js

@@ -10,15 +10,21 @@ export class CollectionEditor {
     path;
     node;
     editor;
+    key;
     value;
     original;
-    constructor(app, path, node, editor) {
+    constructor(app, path, node, editor, 
+    /** The setting's key (a list's own, without positions): what the entries are is read from it. */
+    key = []) {
         this.app = app;
         this.path = path;
         this.node = node;
         this.editor = editor;
+        this.key = key;
     }
     noun = 'entry';
+    /** What leaving with changes does, shown under the list (settings: they wait for Ctrl+S). */
+    keepNote = 'Esc keeps it for saving with Ctrl+S';
     async run(start) {
         this.original = structuredClone(start);
         this.value = structuredClone(start);
@@ -29,9 +35,7 @@ export class CollectionEditor {
             const picked = await this.app.list({
                 path: this.path,
                 intro: this.node.description,
-                status: dirty
-                    ? Theme.changed(Theme.glyph.changed + ' changed: Esc keeps it for saving with Ctrl+S')
-                    : undefined,
+                status: dirty ? Theme.changed(Theme.glyph.changed + ' changed: ' + this.keepNote) : undefined,
                 items: [
                     { value: ADD, label: '+ Add ' + this.noun, section: 'Actions' },
                     ...entries.map((e) => ({
@@ -41,11 +45,11 @@ export class CollectionEditor {
                 ],
                 startAt: focus,
                 actions: [
-                    { key: 'd', label: 'delete' },
-                    ...(this.move
+                    { key: 'd', label: 'remove', applies: (id) => id !== ADD },
+                    ...(this.move && entries.length > 1
                         ? [
-                            { key: 'u', label: 'move up' },
-                            { key: 'j', label: 'move down' },
+                            { key: 'u', label: 'move up', applies: (id) => id !== ADD },
+                            { key: 'j', label: 'move down', applies: (id) => id !== ADD },
                         ]
                         : []),
                 ],

package/dist/cli/menu/settings/collections/map-editor.js

@@ -4,7 +4,11 @@ import { formatValue } from '../format.js';
 export class MapEditor extends CollectionEditor {
     noun = 'variable';
     entries() {
-        return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: formatValue(v) }));
+        return Object.entries(this.value).map(([k, v]) => ({
+            value: k,
+            label: k,
+            hint: this.node.element?.secret ? '***' : formatValue(v),
+        }));
     }
     async add() {
         const name = await this.app.text({

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

@@ -8,12 +8,12 @@ export class ObjectListEditor extends CollectionEditor {
         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);
+        const edited = await new ObjectEditor(this.app, [...this.path, 'New'], this.node.element, this.editor, this.key).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)]);
+        const edited = await new ObjectEditor(this.app, [...this.path, summary(this.value[Number(id)])], this.node.element, this.editor, this.key).run(this.value[Number(id)]);
         if (edited)
             this.value[Number(id)] = edited.value;
     }

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

@@ -20,12 +20,12 @@ export class ObjectMapEditor extends CollectionEditor {
         });
         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);
+        const edited = await new ObjectEditor(this.app, [...this.path, name], this.node.element, this.editor, this.key).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]);
+        const edited = await new ObjectEditor(this.app, [...this.path, id], this.node.element, this.editor, this.key).run(this.value[id]);
         if (edited)
             this.value[id] = edited.value;
     }

package/dist/cli/menu/settings/collections/string-list-editor.d.ts

@@ -1,8 +1,17 @@
-import { type ListItem } from '../../../tui/index.js';
+import type { App, ListItem } from '../../../tui/index.js';
 import { CollectionEditor } from './collection-editor.js';
+import type { PathKind, SchemaNode } from '../../../../app/kernel/index.js';
+import type { ValueEditor } from '../value-editor.js';
 /** A list of strings (project roots, scripts, extra packages ...). */
 export declare class StringListEditor extends CollectionEditor<string[]> {
+    /** The items are folders or files on this PC: they are picked in the path picker. */
+    private readonly pathKind?;
     protected noun: string;
+    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor, key: string[], 
+    /** The items are folders or files on this PC: they are picked in the path picker. */
+    pathKind?: PathKind | undefined, 
+    /** What leaving with changes does, when it is not "wait for Ctrl+S". */
+    keepNote?: string);
     protected entries(): ListItem<string>[];
     private ask;
     protected add(): Promise<void>;

package/dist/cli/menu/settings/collections/string-list-editor.js

@@ -1,13 +1,36 @@
 import { Theme } from '../../../tui/index.js';
 import { CollectionEditor } from './collection-editor.js';
+import { askPath } from '../ask-path.js';
 /** A list of strings (project roots, scripts, extra packages ...). */
 export class StringListEditor extends CollectionEditor {
+    pathKind;
     noun = 'item';
+    constructor(app, path, node, editor, key, 
+    /** The items are folders or files on this PC: they are picked in the path picker. */
+    pathKind, 
+    /** What leaving with changes does, when it is not "wait for Ctrl+S". */
+    keepNote) {
+        super(app, path, node, editor, key);
+        this.pathKind = pathKind;
+        if (pathKind)
+            this.noun = pathKind === 'file' ? 'file' : 'folder';
+        if (keepNote)
+            this.keepNote = keepNote;
+    }
     entries() {
         return this.value.map((v, i) => ({ value: String(i), label: v || Theme.muted('(empty)') }));
     }
     async ask(initial) {
         const element = this.node.element;
+        if (this.pathKind)
+            return askPath(this.app, {
+                path: this.path,
+                title: this.pathKind === 'file' ? 'Choose a file' : 'Choose a folder',
+                about: this.node.description ? [this.node.description] : [],
+                kind: this.pathKind,
+                initial,
+                validate: (v) => element.check(v),
+            });
         return this.app.text({
             path: this.path,
             label: 'Value',

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

@@ -1,4 +1,4 @@
-import type { ConfigFile, SettingChange } from './config-file.js';
+import type { ConfigFile, SettingChange } from '../../../app/features/settings/index.js';
 /** What saving did: how many settings were written and why a file was refused. */
 export interface DraftResult {
     readonly saved: number;

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

@@ -1,5 +1,3 @@
+export { choiceLabel, summary } from '../../../app/kernel/index.js';
 /** 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;