windows-development-sandbox 1.5.0 → 1.7.0

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

@@ -1,31 +1,26 @@
-// How the settings are grouped on screen: categories in the sidebar, readable names for sections and toolchains. Every
-// top-level setting of both files must belong to a category (a self-test checks it), so nothing is ever hidden.
+// How the settings are grouped on screen: categories in the navigation, readable names for sections and toolchains.
+// Every top-level setting of both files must belong to a category or be covered by another section (a self-test checks
+// it), so nothing is ever hidden.
 import { Text } from '../../tui/index.js';
 export const CATEGORIES = [
     {
         id: 'general',
         label: 'General',
-        description: 'Which agent starts, where the project appears in the sandbox, and extra folders from this PC.',
+        description: 'Which agent starts, where the project appears in the sandbox, extra folders from this PC, and where the sandbox keeps its data.',
         keys: ['defaultHarness', 'harness', 'guestWorkspace', 'readOnly', 'mappings', 'scripts'],
     },
     {
         id: 'machine',
         label: 'Sandbox machine',
-        description: 'Memory, CPU, window, GPU, clipboard, audio and network of the sandbox itself.',
-        keys: ['sandbox'],
+        description: 'Memory, CPU, window, GPU, clipboard, audio and networking of the sandbox itself, and its desktop look (theme, accent colour, taskbar, wallpaper).',
+        keys: ['sandbox', 'personalization'],
     },
     {
         id: 'languages',
         label: 'Languages & tools',
-        description: 'Toolchains installed in the sandbox. "auto" follows your project\'s files and what this PC has.',
+        description: 'Toolchains installed in the sandbox. "auto" follows the files of your project and what this PC has.',
         keys: ['toolchains'],
     },
-    {
-        id: 'apps',
-        label: 'Apps',
-        description: 'Desktop apps installed in the sandbox: editors, database clients, API clients, game engines ... (also: Apps catalogue on the home screen).',
-        keys: ['apps'],
-    },
     {
         id: 'databases',
         label: 'Databases',
@@ -34,21 +29,15 @@ export const CATEGORIES = [
     },
     {
         id: 'agents',
-        label: 'Agents & attaching',
-        description: 'The agents you can start, attaching your terminal to them, and the (Beta) agent commands.',
-        keys: ['harnesses', 'attach', 'agentCommands'],
-    },
-    {
-        id: 'claude',
-        label: 'Claude profile',
-        description: 'Which of your Claude settings, history and memory are copied in and synced back.',
-        keys: ['claudeProfile'],
+        label: 'Agents & sessions',
+        description: 'The agents you can start (also: Agents section), attaching your terminal to them, the (Beta) web UI and agent commands, which of your Claude settings are copied in, and reopening sessions.',
+        keys: ['harnesses', 'attach', 'web', 'agentCommands', 'claudeProfile', 'resume'],
     },
     {
         id: 'network',
         label: 'Network',
-        description: 'What the sandbox can reach: your LAN, only some hosts, blocked hosts, DNS, a proxy, and ports forwarded from this PC to servers inside. (No network at all: Sandbox machine > Networking.)',
-        keys: ['network'],
+        description: 'What the sandbox can reach: your LAN, only some hosts, blocked hosts, DNS, a proxy, ports forwarded from this PC to servers inside, and a VPN (with a login set here). (No network at all: Sandbox machine > Networking.)',
+        keys: ['network', 'vpn'],
     },
     {
         id: 'security',
@@ -56,42 +45,28 @@ export const CATEGORIES = [
         description: 'Git-ignored files kept out, secrets kept out of the sandbox, download checks, what is kept on this PC, and sharing your sandbox with other Windows users.',
         keys: ['workspaceFilter', 'audit', 'secrets', 'downloads', 'storage', 'sharing'],
     },
-    {
-        id: 'setup',
-        label: 'Setup & hooks',
-        description: 'How tools get into the sandbox (copied from this PC or downloaded), Git, the terminal, and hook scripts.',
-        keys: ['provisioning', 'hooks'],
-    },
     {
         id: 'projects',
-        label: 'Projects',
-        description: 'Several projects in one sandbox: project roots mapped at every start, adding folders while it runs.',
-        keys: ['projects'],
-    },
-    {
-        id: 'resume',
-        label: 'Reopening sessions',
-        description: 'Open the sessions of the last sandbox again when a new one starts, or after a crash.',
-        keys: ['resume'],
-    },
-    {
-        id: 'desktop',
-        label: 'Desktop look',
-        description: 'Copy your theme, accent colour, taskbar and wallpaper into the sandbox.',
-        keys: ['personalization'],
+        label: 'Projects & setup',
+        description: 'Several projects in one sandbox (roots mapped at every start, adding folders while it runs), how tools get into the sandbox (copied from this PC or downloaded), Git, the terminal, and hook scripts.',
+        keys: ['projects', 'provisioning', 'hooks'],
     },
 ];
+/** Settings not listed here because their own section covers them (Apps: the catalogue and your own programs). */
+export const SETTINGS_ELSEWHERE = ['apps'];
 /** Readable names for sections and toolchains (anything missing gets a name made from its key). */
 const NAMES = {
     sandbox: 'Sandbox machine',
     attach: 'Attaching your terminal',
     agentCommands: 'Agent commands (Beta)',
+    web: 'Web UI (Beta)',
     provisioning: 'Provisioning',
     downloads: 'Downloads',
     secrets: 'Secrets',
     claudeProfile: 'Claude profile',
     storage: 'Storage on this PC',
     network: 'Network',
+    vpn: 'VPN',
     hooks: 'Hooks',
     personalization: 'Desktop look',
     projects: 'Projects',

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

@@ -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,18 @@
-import { type ListItem } from '../../../tui/index.js';
+import type { App, ListItem } from '../../../tui/index.js';
 import { CollectionEditor } from './collection-editor.js';
+import { type PathKind } from '../path-kind.js';
+import type { SchemaNode } from '../schema-node.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 '../path-kind.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/index.d.ts

@@ -1,4 +1,4 @@
-export { CATEGORIES, nameOf } from './categories.js';
+export { CATEGORIES, categoryOf, nameOf, SETTINGS_ELSEWHERE } from './categories.js';
 export { ConfigFile, editConfigText, fileValue, type SettingChange, type SettingsTarget } from './config-file.js';
 export { Draft, type DraftResult } from './draft.js';
 export { SchemaNode } from './schema-node.js';

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

@@ -1,4 +1,4 @@
-export { CATEGORIES, nameOf } from './categories.js';
+export { CATEGORIES, categoryOf, nameOf, SETTINGS_ELSEWHERE } from './categories.js';
 export { ConfigFile, editConfigText, fileValue } from './config-file.js';
 export { Draft } from './draft.js';
 export { SchemaNode } from './schema-node.js';

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

@@ -7,6 +7,10 @@ export declare class ObjectEditor {
     private readonly path;
     private readonly node;
     private readonly editor;
-    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor);
+    /** The setting's key (the object's own, without list positions), so a field knows what it is. */
+    private readonly key;
+    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor, 
+    /** The setting's key (the object's own, without list positions), so a field knows what it is. */
+    key?: string[]);
     run(start: Record<string, unknown>, isNew?: boolean): Promise<Edited>;
 }

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

@@ -7,11 +7,15 @@ export class ObjectEditor {
     path;
     node;
     editor;
-    constructor(app, path, node, editor) {
+    key;
+    constructor(app, path, node, editor, 
+    /** The setting's key (the object's own, without list positions), so a field knows what it is. */
+    key = []) {
         this.app = app;
         this.path = path;
         this.node = node;
         this.editor = editor;
+        this.key = key;
     }
     async run(start, isNew = false) {
         const value = structuredClone(start);
@@ -30,13 +34,20 @@ export class ObjectEditor {
                     ...fields.map(([name, field]) => ({
                         value: name,
                         label: Text.humanize(name),
-                        hint: formatValue(value[name]),
+                        hint: field.secret && value[name] ? '***' : formatValue(value[name]),
                         description: field.description,
                         section: 'Fields',
+                        flip: field.editor === 'boolean',
                     })),
                 ],
                 startAt: focus,
-                actions: [{ key: 'r', label: 'clear' }],
+                actions: [
+                    {
+                        key: 'r',
+                        label: 'clear',
+                        applies: (name) => Boolean(this.node.child(name)?.optional) && value[name] !== undefined,
+                    },
+                ],
             });
             notice = undefined;
             if (picked.kind === 'back') {
@@ -58,7 +69,7 @@ export class ObjectEditor {
                 delete value[name];
                 continue;
             }
-            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [name], field, value[name]);
+            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [...this.key, name], field, value[name]);
             if (edited)
                 value[name] = edited.value;
         }

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

@@ -0,0 +1,20 @@
+import type { App } from '../../tui/index.js';
+import type { SchemaNode } from './schema-node.js';
+/** A folder or a file. */
+export type PathKind = 'dir' | 'file';
+/** The kind of path a setting holds (its key without list positions), or undefined when it is not a path. */
+export declare function pathKindOf(key: readonly string[]): PathKind | undefined;
+/** Words that are fine instead of a path ("auto"), read from the setting's description. */
+export declare function pathLiterals(node: SchemaNode): string[];
+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/path-kind.js

@@ -0,0 +1,44 @@
+/** Top-level settings whose list entries are folders or files, and the single settings that are one. */
+const KINDS = {
+    'storage.root': 'dir',
+    'projects.roots': 'dir',
+    'projects.exclude': 'dir',
+    'projects.declinedRoots': 'dir',
+    'claudeProfile.hostDir': 'dir',
+    'claudeProfile.globalStateFile': 'file',
+    scripts: 'file',
+};
+/** The kind of path a setting holds (its key without list positions), or undefined when it is not a path. */
+export function pathKindOf(key) {
+    const id = key.join('.');
+    const last = key[key.length - 1] ?? '';
+    if (KINDS[id])
+        return KINDS[id];
+    if (key[0] === 'mappings' && last === 'host')
+        return 'dir';
+    if (last === 'hostDir')
+        return 'dir';
+    if (/(Dir|Folder)$/.test(last))
+        return 'dir';
+    if (/File$/.test(last))
+        return 'file';
+    return undefined;
+}
+/** Words that are fine instead of a path ("auto"), read from the setting's description. */
+export function pathLiterals(node) {
+    return /"auto"/.test(node.description ?? '') ? ['auto'] : [];
+}
+/** 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/schema-node.d.ts

@@ -20,6 +20,7 @@ type ZodLike = z.ZodType & {
     description?: string;
     minValue?: number | null;
     maxValue?: number | null;
+    isInt?: boolean;
 };
 /** The editor a setting gets. */
 export type EditorKind = 'boolean' | 'choice' | 'union' | 'number' | 'string' | 'string-list' | 'choice-list' | 'object-list' | 'string-map' | 'object-map' | 'object' | 'json';
@@ -35,6 +36,14 @@ export declare class SchemaNode {
     get description(): string | undefined;
     get min(): number | undefined;
     get max(): number | undefined;
+    /** A number that must be whole. */
+    get integer(): boolean;
+    /** A secret (an API key): shown as ***, typed with each character hidden. */
+    get secret(): boolean;
+    /** May the setting be left out (optional or with a default)? */
+    get optional(): boolean;
+    /** The numbers allowed, in words: "1 to 65535", "at least 2048", "more than 0", "" without limits. */
+    rangeText(): string;
     /** The fields of an object, in schema order. */
     children(): [string, SchemaNode][];
     child(name: string): SchemaNode | undefined;

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

@@ -35,6 +35,32 @@ export class SchemaNode {
     get max() {
         return this.inner.maxValue ?? undefined;
     }
+    /** A number that must be whole. */
+    get integer() {
+        return Boolean(this.inner.isInt);
+    }
+    /** A secret (an API key): shown as ***, typed with each character hidden. */
+    get secret() {
+        const meta = (z) => z.meta?.();
+        return meta(this.schema)?.secret === true || meta(this.inner)?.secret === true;
+    }
+    /** May the setting be left out (optional or with a default)? */
+    get optional() {
+        return ['optional', 'default'].includes(this.schema._zod.def.type);
+    }
+    /** The numbers allowed, in words: "1 to 65535", "at least 2048", "more than 0", "" without limits. */
+    rangeText() {
+        const checks = (this.inner._zod.def.checks ?? []).map((c) => c._zod.def);
+        const lower = checks.find((c) => c.check === 'greater_than');
+        const upper = checks.find((c) => c.check === 'less_than');
+        const lo = lower?.value;
+        const hi = upper?.value;
+        if (lo !== undefined && hi !== undefined && lower?.inclusive !== false && upper?.inclusive !== false)
+            return lo + ' to ' + hi;
+        const low = lo === undefined ? '' : (lower?.inclusive === false ? 'more than ' : 'at least ') + lo;
+        const high = hi === undefined ? '' : (upper?.inclusive === false ? 'less than ' : 'at most ') + hi;
+        return [low, high].filter(Boolean).join(' and ');
+    }
     /** The fields of an object, in schema order. */
     children() {
         return Object.entries(this.inner.shape ?? {})

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

@@ -1,5 +1,7 @@
 import { type App } from '../../tui/index.js';
 import { type SchemaNode } from './schema-node.js';
+/** What is wrong with the text typed for a number setting (true = fine), in words that name the allowed range. */
+export declare function numberProblem(node: SchemaNode, text: string): true | string;
 /** The new value, or undefined when you backed out without changing anything. */
 export type Edited = {
     value: unknown;
@@ -13,6 +15,9 @@ export declare class ValueEditor {
     private readonly hints;
     constructor(app: App, hints?: EditorHints);
     edit(path: string[], key: string[], node: SchemaNode, current: unknown): Promise<Edited>;
+    private number;
+    /** A folder or file on this PC: the path picker (typing a path still works). */
+    private folderOrFile;
     private pick;
     private suggest;
     private json;

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

@@ -9,6 +9,20 @@ import { MapEditor } from './collections/map-editor.js';
 import { ObjectListEditor } from './collections/object-list-editor.js';
 import { ObjectMapEditor } from './collections/object-map-editor.js';
 import { ObjectEditor } from './object-editor.js';
+import { askPath, pathKindOf, pathLiterals } from './path-kind.js';
+/** What is wrong with the text typed for a number setting (true = fine), in words that name the allowed range. */
+export function numberProblem(node, text) {
+    const n = Number(text);
+    if (text.trim() === '' || !Number.isFinite(n))
+        return 'Enter a number.';
+    if (node.integer && !Number.isInteger(n))
+        return 'Enter a whole number.';
+    const verdict = node.check(n);
+    if (verdict === true)
+        return true;
+    const range = node.rangeText();
+    return range ? 'Use ' + range + '.' : verdict;
+}
 export class ValueEditor {
     app;
     hints;
@@ -47,26 +61,19 @@ export class ValueEditor {
                     ? 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 'number':
+                return this.number(path, key, node, current);
             case 'string': {
+                const kind = pathKindOf(key);
+                if (kind)
+                    return this.folderOrFile(path, key, node, current, kind);
                 const typed = await this.app.text({
                     path,
                     label: Text.humanize(key[key.length - 1]),
                     about,
                     initial: typeof current === 'string' ? current : '',
                     allowEmpty: node.check('') === true,
+                    masked: node.secret,
                     validate: (v) => node.check(v),
                 });
                 return typed === undefined ? undefined : { value: typed };
@@ -82,19 +89,45 @@ export class ValueEditor {
                 return picked.kind === 'multi' ? { value: picked.values } : undefined;
             }
             case 'string-list':
-                return new StringListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
+                return new StringListEditor(this.app, path, node, this, key, pathKindOf(key)).run(Array.isArray(current) ? current : []);
             case 'string-map':
-                return new MapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
+                return new MapEditor(this.app, path, node, this, key).run(_.isPlainObject(current) ? current : {});
             case 'object-list':
-                return new ObjectListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
+                return new ObjectListEditor(this.app, path, node, this, key).run(Array.isArray(current) ? current : []);
             case 'object-map':
-                return new ObjectMapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
+                return new ObjectMapEditor(this.app, path, node, this, key).run(_.isPlainObject(current) ? current : {});
             case 'object':
-                return new ObjectEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : node.initial());
+                return new ObjectEditor(this.app, path, node, this, key).run(_.isPlainObject(current) ? current : node.initial());
             default:
                 return this.json(path, key, node, current);
         }
     }
+    async number(path, key, node, current) {
+        const range = node.rangeText();
+        const typed = await this.app.text({
+            path,
+            label: Text.humanize(key[key.length - 1]),
+            about: node.description ? [node.description] : [],
+            hint: 'A ' + (node.integer ? 'whole number' : 'number') + (range ? ': ' + range : '') + '.',
+            accept: node.integer ? (node.min !== undefined && node.min >= 0 ? /[0-9]/ : /[-0-9]/) : /[-0-9.]/,
+            initial: current === undefined ? '' : String(current),
+            validate: (v) => numberProblem(node, v),
+        });
+        return typed === undefined ? undefined : { value: Number(typed) };
+    }
+    /** A folder or file on this PC: the path picker (typing a path still works). */
+    async folderOrFile(path, key, node, current, kind) {
+        const picked = await askPath(this.app, {
+            path,
+            title: 'Choose ' + (kind === 'file' ? 'the file' : 'the folder') + ': ' + Text.humanize(key[key.length - 1]),
+            about: node.description ? [node.description] : [],
+            kind,
+            initial: typeof current === 'string' && current !== 'auto' ? current : '',
+            literals: pathLiterals(node),
+            validate: (v) => node.check(v),
+        });
+        return picked === undefined ? undefined : { value: picked };
+    }
     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 };