windows-development-sandbox 1.7.0 → 1.10.0

package/dist/cli/menu/io-menu.js

@@ -0,0 +1,126 @@
+// Running the shared core's actions inside the menu: an operation's questions become the menu's dialogs (yes/no over
+// the screen, a text field, the path picker, a list), its fields the settings editors, its progress the page's notice,
+// and what it said so far is shown above its next question. The result is one notice line: what it did, or what went
+// wrong and how to fix it. A link leaves the menu for what needs the terminal (attach, a start).
+import { operationById } from '../../app/features/defs.js';
+import { runDefinition } from '../../app/registry.js';
+import { Cancelled, ioFromAsker, SchemaNode, toWireError, } from '../../app/kernel/index.js';
+import { errMsg } from '../../core/util/index.js';
+import { Theme } from '../tui/index.js';
+import { askPath } from './settings/ask-path.js';
+import { ValueEditor } from './settings/value-editor.js';
+async function ask(app, where, q, said) {
+    const lines = [...said, ...(q.lines ?? []), ...('problem' in q && q.problem ? [Theme.warn(q.problem)] : [])];
+    const path = [...where];
+    switch (q.kind) {
+        case 'confirm': {
+            if (!q.typed)
+                return app.ask(q.title, lines, q.yes ?? 'Yes', q.danger ?? false);
+            const typed = await app.text({ path, label: 'Type "' + q.typed + '" to confirm', about: [q.title, ...lines] });
+            return typed?.trim().toLowerCase() === q.typed;
+        }
+        case 'choose':
+            return app.choose(path, [q.title, ...lines].join(' '), q.choices, q.initial);
+        case 'checklist': {
+            const picked = await app.list({
+                path,
+                intro: [q.title, ...lines],
+                multi: true,
+                items: q.choices.map((ch) => ({ ...ch, checked: q.checked?.includes(ch.value) ?? false })),
+            });
+            return picked.kind === 'multi' ? picked.values : undefined;
+        }
+        case 'path':
+            return askPath(app, {
+                path,
+                title: q.title,
+                about: lines,
+                kind: q.pathKind,
+                initial: q.initial,
+                literals: q.literals,
+            });
+        case 'text':
+        case 'secret':
+            return app.text({
+                path,
+                label: q.title,
+                about: lines,
+                initial: q.kind === 'text' ? q.initial : undefined,
+                allowEmpty: q.kind === 'text' ? q.allowEmpty : false,
+                masked: q.kind === 'secret',
+            });
+    }
+}
+/** Where a link goes in the menu: what needs the terminal is run on the normal screen. */
+function follow(target) {
+    switch (target.kind) {
+        case 'terminal':
+            return { exit: { kind: 'run', argv: ['attach', target.session] } };
+        case 'start-agent':
+            return { exit: { kind: 'run', argv: ['launch', '--harness', target.agent] } };
+        case 'command':
+            return { exit: { kind: 'run', argv: [...target.argv] } };
+        case 'view':
+            return {};
+    }
+}
+export class MenuOperations {
+    app;
+    ctx;
+    constructor(app, ctx) {
+        this.app = app;
+        this.ctx = ctx;
+    }
+    /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
+    async perform(action, where, busy) {
+        if (action.kind === 'link')
+            return follow(action.target);
+        const def = operationById(action.op);
+        if (!def)
+            return { notice: Theme.error(Theme.glyph.cross + ' Unknown operation ' + action.op + '.') };
+        const answers = await this.fields(action, def, where);
+        if (!answers)
+            return {};
+        return { reload: true, notice: await this.run(def, { ...action.input, ...answers }, where, busy) };
+    }
+    /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */
+    async fields(action, def, where) {
+        const answers = {};
+        const editor = new ValueEditor(this.app);
+        for (const field of action.fields ?? []) {
+            const node = new SchemaNode(def.input).child(field.name);
+            if (!node)
+                continue;
+            const edited = await editor.edit([...where, field.label], [...field.key], node, action.initial?.[field.name]);
+            if (!edited)
+                return undefined;
+            answers[field.name] = edited.value;
+        }
+        return answers;
+    }
+    /**
+     * Runs a definition with this input and returns the notice to show: its text (✓), the problem and its fix (✘), or
+     * undefined when a question was declined (nothing changed, nothing to say).
+     */
+    async run(def, input, where, busy = () => undefined) {
+        const said = [];
+        const asker = async (q) => (await ask(this.app, where, q, said.splice(0)));
+        const io = ioFromAsker(asker, {
+            progress: (text) => busy(Theme.muted(text + '…')),
+            log: (text, tone) => said.push(tone === 'warn' || tone === 'danger' ? Theme.warn(text) : text),
+        });
+        try {
+            const output = await runDefinition(def.id, this.ctx, input, io);
+            const text = def.text?.(output);
+            return text ? Theme.ok(Theme.glyph.ok + ' ' + text) : undefined;
+        }
+        catch (e) {
+            if (e instanceof Cancelled)
+                return undefined;
+            const problem = toWireError(e);
+            if (problem.kind === 'bug')
+                return Theme.error(Theme.glyph.cross + ' ' + errMsg(e));
+            return (Theme.error(Theme.glyph.cross + ' ' + problem.message) + (problem.fix ? Theme.muted('  ' + problem.fix) : ''));
+        }
+    }
+}

package/dist/cli/menu/live.d.ts

@@ -0,0 +1,27 @@
+export interface LiveOptions {
+    /** Fetches the process list (default: tasklist, run without blocking). */
+    readonly fetch?: () => Promise<string>;
+    /** The status line from the facts now (reads the cached process list and small files; never runs a program). */
+    readonly derive: () => string;
+    /** The line changed: draw again. */
+    readonly onChange: () => void;
+    readonly intervalMs?: number;
+}
+export declare class LiveStatus {
+    private readonly o;
+    private tasklist;
+    private text;
+    private timer;
+    private pending;
+    private running;
+    constructor(o: LiveOptions);
+    /** The status line as of the last refresh. */
+    line(): string;
+    /** Reads the process list now and derives the line (one fetch at a time; a caller during one waits for it). */
+    refresh(): Promise<void>;
+    private derive;
+    /** Starts keeping the line fresh and answers the host's process questions from it (until stop). */
+    start(): Promise<void>;
+    /** Stops; the host's questions run their own programs again (a command that runs after the menu needs the truth). */
+    stop(): void;
+}

package/dist/cli/menu/live.js

@@ -0,0 +1,69 @@
+// What the menu shows about the running sandbox (the status line), kept fresh in the background. Drawing and keys only
+// read the last copy: the process list is fetched without blocking (every few seconds, and after an action), and the
+// screen is told when what it shows has changed. While it runs, the host's own "is the sandbox running?" questions are
+// answered from the same copy, so no page waits for a child process.
+import { sandboxStatus } from '../../app/features/sandbox/index.js';
+import { readTasklistAsync, useTasklistCache } from '../../host/sandbox/index.js';
+/** The same rule as the web's live status: the sandbox status query's interval. */
+const DEFAULT_INTERVAL_MS = sandboxStatus.live?.everyMs ?? 2500;
+export class LiveStatus {
+    o;
+    tasklist;
+    text = '';
+    timer;
+    pending;
+    running = false;
+    constructor(o) {
+        this.o = o;
+    }
+    /** The status line as of the last refresh. */
+    line() {
+        return this.text;
+    }
+    /** Reads the process list now and derives the line (one fetch at a time; a caller during one waits for it). */
+    refresh() {
+        this.pending ??= (async () => {
+            try {
+                const list = await (this.o.fetch ?? readTasklistAsync)();
+                // Stopped meanwhile: a command may be running, and nothing here may touch the host's facts any more.
+                if (!this.running)
+                    return;
+                this.tasklist = list;
+                this.derive();
+            }
+            catch {
+                // The line keeps what it showed; the next refresh tries again.
+            }
+            finally {
+                this.pending = undefined;
+            }
+        })();
+        return this.pending;
+    }
+    derive() {
+        const next = this.o.derive();
+        if (next === this.text)
+            return;
+        this.text = next;
+        if (this.running)
+            this.o.onChange();
+    }
+    /** Starts keeping the line fresh and answers the host's process questions from it (until stop). */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        useTasklistCache(() => this.tasklist);
+        this.timer = setInterval(() => void this.refresh(), this.o.intervalMs ?? DEFAULT_INTERVAL_MS);
+        this.timer.unref();
+        await this.refresh();
+    }
+    /** Stops; the host's questions run their own programs again (a command that runs after the menu needs the truth). */
+    stop() {
+        this.running = false;
+        clearInterval(this.timer);
+        this.timer = undefined;
+        useTasklistCache(null);
+        this.tasklist = undefined;
+    }
+}

package/dist/cli/menu/memory.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { MenuView } from './shell.js';
+declare const MenuStateSchema: z.ZodObject<{
+    section: z.ZodString;
+    screens: z.ZodRecord<z.ZodString, z.ZodObject<{
+        category: z.ZodOptional<z.ZodString>;
+        search: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type MenuState = z.output<typeof MenuStateSchema>;
+/** The view as it is stored: the section by name, so a menu with other sections still finds its way. */
+export declare function viewToState(view: MenuView, labels: readonly string[]): MenuState;
+/** A stored state as a view; a section that no longer exists falls back to the first. */
+export declare function stateToView(state: MenuState, labels: readonly string[]): MenuView;
+/** The view the last run left (undefined when there is none or the file is not valid). */
+export declare function readMenuView(labels: readonly string[], dir?: string): MenuView | undefined;
+/** Remembers the view for the next run. Never fails the menu. */
+export declare function saveMenuView(view: MenuView, labels: readonly string[], dir?: string): void;
+export {};

package/dist/cli/menu/memory.js

@@ -0,0 +1,53 @@
+// Where the menu was left, kept in ~/.agent-sandbox/menu-state.json: the open section and, for each section, its
+// category and search. A convenience only: a missing, invalid or unwritable file means the menu opens on Agents.
+import path from 'node:path';
+import { z } from 'zod';
+import { userDir } from '../../core/config/index.js';
+import { JsonFile } from '../../shared/io/index.js';
+const ScreenSchema = z.strictObject({
+    category: z.string().max(100).optional(),
+    search: z.string().max(200).optional(),
+});
+const MenuStateSchema = z.strictObject({
+    section: z.string().max(40),
+    screens: z.record(z.string().max(40), ScreenSchema),
+});
+function stateFile(dir) {
+    return new JsonFile(MenuStateSchema, path.join(dir, 'menu-state.json'));
+}
+/** The view as it is stored: the section by name, so a menu with other sections still finds its way. */
+export function viewToState(view, labels) {
+    const screens = {};
+    for (const [label, screen] of Object.entries(view.screens))
+        if (labels.includes(label) && (screen.category || screen.search))
+            screens[label] = screen;
+    return { section: labels[view.section] ?? labels[0] ?? '', screens };
+}
+/** A stored state as a view; a section that no longer exists falls back to the first. */
+export function stateToView(state, labels) {
+    const section = labels.indexOf(state.section);
+    return {
+        section: section < 0 ? 0 : section,
+        screens: Object.fromEntries(Object.entries(state.screens).filter(([label]) => labels.includes(label))),
+    };
+}
+/** The view the last run left (undefined when there is none or the file is not valid). */
+export function readMenuView(labels, dir = userDir()) {
+    try {
+        const state = stateFile(dir).read();
+        return state ? stateToView(state, labels) : undefined;
+    }
+    catch {
+        // The state is a convenience: an unreadable file counts as none.
+        return undefined;
+    }
+}
+/** Remembers the view for the next run. Never fails the menu. */
+export function saveMenuView(view, labels, dir = userDir()) {
+    try {
+        stateFile(dir).write(viewToState(view, labels));
+    }
+    catch {
+        // Not remembering is fine.
+    }
+}

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

@@ -1,9 +1,18 @@
 import type { Context } from '../commands/context.js';
+import { Terminal } from '../tui/index.js';
+/** What a test may replace: the terminal, the process list fetch and how often it is fetched. */
+export interface MenuOptions {
+    readonly terminal?: Terminal;
+    readonly fetchTasklist?: () => Promise<string>;
+    readonly refreshMs?: number;
+}
 export declare class Menu {
     private readonly ctx;
     private readonly runArgv;
     private readonly app;
-    constructor(ctx: Context, runArgv: (argv: string[]) => Promise<number>);
+    private readonly live;
+    constructor(ctx: Context, runArgv: (argv: string[]) => Promise<number>, options?: MenuOptions);
+    /** The status line from the facts now: only ever called by the background refresh, never by a draw or a key. */
     private status;
     /** The sections, in order. */
     private shell;

package/dist/cli/menu/menu.js

@@ -11,7 +11,7 @@ import { lookAtSandbox } from '../commands/shared-use.js';
 import { commandLine } from '../history.js';
 import { commandSpec } from '../manifest.js';
 import { AgentCommandsService, LogsService } from '../services/index.js';
-import { App, ExitRequested, Frame, Text, Theme } from '../tui/index.js';
+import { App, ExitRequested, Frame, Terminal, Text, Theme } from '../tui/index.js';
 import { AccountsPage } from './pages/accounts-page.js';
 import { AgentsPage } from './pages/agents-page.js';
 import { AppsPage } from './pages/apps-page.js';
@@ -19,19 +19,30 @@ import { MaintenancePage } from './pages/maintenance-page.js';
 import { SandboxPage } from './pages/sandbox-page.js';
 import { SessionsPage } from './pages/sessions-page.js';
 import { SettingsPage } from './pages/settings-page.js';
-import { ConfigFile } from './settings/config-file.js';
+import { ConfigFile } from '../../app/features/settings/index.js';
 import { Draft } from './settings/draft.js';
-import { Shell } from './shell.js';
-/** Where the menu was last left in this run: it opens there again (a new run opens on Agents). */
+import { LiveStatus } from './live.js';
+import { readMenuView, saveMenuView } from './memory.js';
+import { SECTION_LABELS, Shell } from './shell.js';
+/** Where the menu was last left: it opens there again (also in a later run, from menu-state.json). */
 let lastView;
 export class Menu {
     ctx;
     runArgv;
-    app = new App();
-    constructor(ctx, runArgv) {
+    app;
+    live;
+    constructor(ctx, runArgv, options = {}) {
         this.ctx = ctx;
         this.runArgv = runArgv;
-        this.app.status = () => this.status();
+        this.app = new App(options.terminal ?? new Terminal());
+        this.live = new LiveStatus({
+            fetch: options.fetchTasklist,
+            derive: () => this.status(),
+            onChange: () => this.app.requestRedraw(),
+            intervalMs: options.refreshMs,
+        });
+        this.app.status = () => this.live.line();
+        this.app.afterAction = () => this.live.refresh();
         try {
             Frame.version =
                 JSON.parse(fs.readFileSync(path.join(ctx.packageRoot, 'package.json'), 'utf8'))
@@ -41,6 +52,7 @@ export class Menu {
             /* no version shown */
         }
     }
+    /** The status line from the facts now: only ever called by the background refresh, never by a draw or a key. */
     status() {
         const folder = Theme.muted(Text.middle(process.cwd(), 70));
         if (!isSandboxRunning())
@@ -77,18 +89,22 @@ export class Menu {
     }
     /** Runs the menu until you leave it, or until a command that takes over the terminal (attach) has run. */
     async start() {
-        if (!process.stdin.isTTY) {
+        if (!this.app.terminal.interactive) {
             console.log('The menu needs an interactive terminal. Run sandbox --help for the commands.');
             return 1;
         }
         try {
             const shell = this.shell();
-            await shell.restore(lastView ?? { section: 0, category: undefined });
+            await this.live.start();
+            await shell.restore(lastView ?? readMenuView(SECTION_LABELS) ?? { section: 0, screens: {} });
             for (;;) {
                 const exit = await this.app.show(shell);
                 lastView = shell.view();
+                saveMenuView(lastView, SECTION_LABELS);
                 if (exit.kind === 'quit')
                     return 0;
+                // A command (or a log) runs on its own facts, not on the menu's copy.
+                this.live.stop();
                 if (exit.kind === 'view')
                     await this.view(exit.file);
                 else {
@@ -96,6 +112,7 @@ export class Menu {
                     if (code !== undefined)
                         return code;
                 }
+                await this.live.start();
                 await shell.reload();
             }
         }
@@ -106,6 +123,7 @@ export class Menu {
             throw e;
         }
         finally {
+            this.live.stop();
             this.app.close();
         }
     }

package/dist/cli/menu/pages/agents-page.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../commands/context.js';
 import { type App, type Category, type ListAction, type ListOptions, type ListResult } from '../../tui/index.js';
-import type { ConfigFile } from '../settings/config-file.js';
+import type { ConfigFile } from '../../../app/features/settings/index.js';
 import type { Draft } from '../settings/draft.js';
 import { ListPage, type Outcome } from './list-page.js';
 export type WindowChoice = 'config' | 'hide' | 'show';
@@ -46,6 +46,8 @@ export declare class AgentsPage extends ListPage<string> {
     private window;
     private folder;
     private model;
+    /** What load() looked up (programs on PATH, the history file): not asked again for every list that is built. */
+    private facts;
     constructor(app: App, ctx: Context, 
     /** Your own config file and its unsaved changes: where "Add an agent" writes to. */
     file: ConfigFile, draft: Draft);

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

@@ -11,7 +11,7 @@ import { commandSpec } from '../../manifest.js';
 import { Text, Theme, } from '../../tui/index.js';
 import { AddAgent, makeDefaultAgent, removeAgent } from '../add-agent.js';
 import { CommandForm } from '../command-form.js';
-import { askPath } from '../settings/path-kind.js';
+import { askPath } from '../settings/ask-path.js';
 import { SeveralAgents } from '../several.js';
 import { ListPage } from './list-page.js';
 /** The agents of `harnesses` that are not built in. Pure. */
@@ -195,6 +195,8 @@ export class AgentsPage extends ListPage {
     window = 'config';
     folder = process.cwd();
     model;
+    /** What load() looked up (programs on PATH, the history file): not asked again for every list that is built. */
+    facts;
     constructor(app, ctx, 
     /** Your own config file and its unsaved changes: where "Add an agent" writes to. */
     file, draft) {
@@ -220,12 +222,14 @@ export class AgentsPage extends ListPage {
     }
     current() {
         const harnesses = this.harnesses();
-        const commands = new AgentCommandsService(this.ctx).status();
+        if (!this.facts)
+            throw new Error('The agents tab was not loaded');
+        const { commands, last } = this.facts;
         return {
             folder: this.folder,
             defaultAgent: this.file.userConfig().defaultHarness,
             agents: Object.keys(harnesses).map((name) => ({ name, ready: this.installed(name, harnesses) })),
-            last: readHistory()[0]?.argv,
+            last,
             attach: this.attach,
             window: this.window,
             hostAgents: hostAgentsToShow(commands.enabled, commands.found),
@@ -236,9 +240,12 @@ export class AgentsPage extends ListPage {
     initialFocus() {
         return 'agent:' + this.file.userConfig().defaultHarness;
     }
-    load() {
+    async load() {
+        this.facts = {
+            commands: await new AgentCommandsService(this.ctx).statusAsync(),
+            last: readHistory()[0]?.argv,
+        };
         this.model = this.current();
-        return Promise.resolve();
     }
     options() {
         this.model = this.current();

package/dist/cli/menu/pages/apps-page.d.ts

@@ -1,6 +1,6 @@
 import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
 import { AppsModel } from '../apps.js';
-import type { ConfigFile } from '../settings/config-file.js';
+import type { ConfigFile } from '../../../app/features/settings/index.js';
 import type { Draft } from '../settings/draft.js';
 import { type Scope } from './scopes.js';
 import { ListPage, type Outcome } from './list-page.js';
@@ -22,5 +22,7 @@ export declare class AppsPage extends ListPage<string> {
     protected options(): ListOptions<string>;
     /** Every tick is staged as it happens, so leaving or saving always sees it. */
     protected afterKey(): Step<ShellExit>;
+    /** Opens the GitHub request form in the browser and says where it is. */
+    private request;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
 }

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

@@ -2,7 +2,8 @@
 // scopes like Settings: apps for every project, or for this project only.
 import { errMsg } from '../../../core/util/index.js';
 import { Theme } from '../../tui/index.js';
-import { AppsModel } from '../apps.js';
+import { openIssuePage } from '../../../host/web/index.js';
+import { AppsModel, requestAppUrl } from '../apps.js';
 import { ValueEditor } from '../settings/value-editor.js';
 import { SCOPES, scopeStatus } from './scopes.js';
 import { ListPage } from './list-page.js';
@@ -17,7 +18,10 @@ export function appsOptions(model, file, draft, scope) {
         enterTicks: true,
         categories: model.categories(),
         items: model.items(draft),
-        actions: file.isProject ? [] : [{ key: 'c', label: 'your own programs' }],
+        actions: [
+            ...(file.isProject ? [] : [{ key: 'c', label: 'your own programs' }]),
+            { key: 'r', label: 'request an app' },
+        ],
     };
 }
 export class AppsPage extends ListPage {
@@ -50,12 +54,25 @@ export class AppsPage extends ListPage {
         this.model.stageTicks(this.draft, this.ticked());
         return;
     }
+    /** Opens the GitHub request form in the browser and says where it is. */
+    request() {
+        const url = requestAppUrl();
+        try {
+            openIssuePage(url);
+            return Theme.ok(Theme.glyph.ok + ' Opened the request form in your browser: ') + Theme.muted(url);
+        }
+        catch (e) {
+            return Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) + Theme.muted('  Open it yourself: ' + url);
+        }
+    }
     async act(result) {
         this.model.stageTicks(this.draft, this.ticked());
         if (result.kind === 'tab') {
             this.scope = SCOPES[result.index].scope;
             return {};
         }
+        if (result.kind === 'action' && result.key === 'r')
+            return { notice: this.request() };
         if (result.kind !== 'action' || result.key !== 'c')
             return {};
         const node = this.file.schema.child('apps')?.child('custom');

package/dist/cli/menu/pages/list-page.d.ts

@@ -20,6 +20,14 @@ export declare abstract class ListPage<T> implements Page {
     private focused;
     /** The entry that was last acted on: the cursor returns to it when the section opens again. */
     private lastFocus;
+    /** A search to start the next list with (restored from the last run); used once. */
+    private pendingQuery;
+    /** The data has arrived at least once (until then the list is "Loading…"). */
+    private loaded;
+    /** Counts loads, so that a slow one that was overtaken does not replace newer data. */
+    private generation;
+    /** A category asked for before the data arrived: it opens when it does. */
+    private wantedCategory;
     constructor(app: App);
     /** Loads the data the list shows (called when the tab opens and after actions that change it). */
     protected abstract load(): Promise<void>;
@@ -29,9 +37,15 @@ export declare abstract class ListPage<T> implements Page {
     protected initialFocus(): T | undefined;
     /** Does what the list returned. */
     protected abstract act(result: ListResult<T>): Promise<Outcome<T>>;
+    /** The data has not arrived yet (the tab shows "Loading…"). */
+    get loading(): boolean;
     get capturing(): boolean;
     /** The id of the open category, if the list has any. */
     get category(): string | undefined;
+    /** The search typed in the list ('' when none). */
+    get search(): string;
+    /** Shows the list with this search typed (the menu opens on the search it was left on). */
+    restoreSearch(text: string): void;
     categories(): readonly Category[];
     selectCategory(id: string): Promise<void>;
     setFocus(list: boolean): void;
@@ -41,7 +55,20 @@ export declare abstract class ListPage<T> implements Page {
     private build;
     /** The entries ticked in a multi-select list. */
     protected ticked(): T[];
+    /** Loads the data again; a slow load does not hold up the keys (the tab keeps what it showed, then updates). */
     open(): Promise<void>;
+    /**
+     * Loads the data and waits for it at most QUICK_LOAD_MS. In time, the list is built here (`build`) or by the caller;
+     * later, the list is built when the data arrives, on the entry and search the user has moved to meanwhile.
+     */
+    private reload;
+    private loadData;
+    /** Back on the entry used last, when it is still in the category that is open. */
+    private rebuildOpened;
+    /** Data that came after the keys stopped waiting: the cursor and the search stay where the user moved them. */
+    private rebuildLate;
+    private rebuildOn;
+    private openWantedCategory;
     /** Builds the list again, on `focus` when it is still there. */
     protected rebuild(focus: T | undefined, notice?: string): void;
     /** Shows `text` now, before slow work starts. */