@north-light/crouter 0.3.235 → 0.3.237

package/dist/commands/sys/context/admin/shell.js

@@ -0,0 +1,669 @@
+// The `crtr sys context admin` page: a snapshot rail, the document matrix, and
+// the dossier that edits one document's routing. The rail decides WHAT is being
+// planned, the matrix shows WHERE every document lands, and the dossier is the
+// only place a write starts.
+import { Input, matchesKey, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
+import { formatGesture, matchesPiTuiInput, } from '../../../../core/keybindings/index.js';
+import { runTuiPage } from '../../../../core/tui/page-host.js';
+import { PAGE_CHROME_ROWS, columns, framed, pageFrame, theme, } from '../../../../core/tui/panel.js';
+import { RUNGS, SURFACE_EVENTS, SURFACE_RUNGS, } from '../../../../core/substrate/schema.js';
+import { profileNameFor } from '../../../../core/substrate/subject-fields.js';
+import { editBufferInEditor } from '../../../../clients/inbox/review/roundtrip.js';
+import { capOwnerFor, moveDoc, readBody, readOnlyReason, toggleFlag, writeBody, writeCap, writeGate, writeRoutingLine, writeShortForm, writeSurfaces, } from './actions.js';
+import { axesOf, cycleAxis, setTypedAxis, renderAxes, typedAxisValue } from './axes-panel.js';
+import { ContextDetailPanel } from './detail-panel.js';
+import { ContextDocsPanel, buildRows } from './docs-panel.js';
+import { PlanSet, plural } from './model.js';
+const RAIL_WIDTH = 26;
+const DOCS_WIDTH = 38;
+const RAIL_MIN_TOTAL_WIDTH = 86;
+const THREE_COLUMN_MIN_WIDTH = 112;
+export class ContextAdminShell {
+    tui;
+    terminalRows;
+    bindings;
+    suspendForChild;
+    snapshot;
+    plans;
+    zone = 'axes';
+    axisIndex = 0;
+    docs;
+    detail = new ContextDetailPanel();
+    modal;
+    notice;
+    busy;
+    edited = new Set();
+    capChanges = [];
+    _focused = false;
+    onCancel;
+    onSubmit;
+    constructor(seed, tui, terminalRows, bindings, suspendForChild) {
+        this.tui = tui;
+        this.terminalRows = terminalRows;
+        this.bindings = bindings;
+        this.suspendForChild = suspendForChild;
+        this.snapshot = seed;
+        this.plans = new PlanSet(seed);
+        this.docs = new ContextDocsPanel(() => this.tui.requestRender());
+        this.rebuild();
+    }
+    set focused(value) {
+        this._focused = value;
+    }
+    get focused() {
+        return this._focused;
+    }
+    /** Required by `Component`. Nothing is cached between frames: a plan can land
+     *  from a warm tick and an edit can land from an await, both between inputs. */
+    invalidate() { }
+    dispose() {
+        this.plans.dispose();
+    }
+    // planning
+    /** Recompute the focused event's plan, refresh the panels from it, and let
+     *  the remaining events fill in behind it. */
+    rebuild(selectedKey) {
+        this.plans.plan(this.snapshot.event);
+        this.docs.setRows(buildRows(this.plans, this.snapshot.event), selectedKey ?? this.docs.selected?.key);
+        this.syncDetail();
+        this.plans.warm(() => {
+            this.docs.setRows(buildRows(this.plans, this.snapshot.event), this.docs.selected?.key);
+            this.syncDetail();
+            this.tui.requestRender();
+        });
+    }
+    syncDetail() {
+        const row = this.docs.selected;
+        const capOwner = row === undefined ? null : capOwnerFor(row.anchor, this.snapshot.profileId);
+        const readOnly = row === undefined ? null : readOnlyReason(row.anchor, this.snapshot.profileId);
+        this.detail.setContext(row, this.snapshot.event, capOwner, readOnly);
+    }
+    setSnapshot(next) {
+        this.snapshot = next;
+        this.plans.setSnapshot(next);
+        this.notice = undefined;
+        this.rebuild();
+    }
+    // input
+    matches(id, data) {
+        return matchesPiTuiInput(this.bindings, id, data, (input, gesture) => matchesKey(input, gesture));
+    }
+    label(id, fallback) {
+        const gestures = this.bindings.gestures(id);
+        return gestures.length === 0 ? fallback : formatGesture(gestures[0].split(' > ').pop());
+    }
+    isDown(data) {
+        return matchesKey(data, 'j') || matchesKey(data, 'down') || this.matches('crtr.setup.list-down', data);
+    }
+    isUp(data) {
+        return matchesKey(data, 'k') || matchesKey(data, 'up') || this.matches('crtr.setup.list-up', data);
+    }
+    isDescend(data) {
+        return (matchesKey(data, 'l') ||
+            matchesKey(data, 'right') ||
+            matchesKey(data, 'enter') ||
+            this.matches('crtr.setup.advance', data));
+    }
+    isAscend(data) {
+        return matchesKey(data, 'h') || matchesKey(data, 'left');
+    }
+    /** Tab steps the focused event from any zone — the one axis every panel is
+     *  drawn against, so it earns the page-level gesture. */
+    cyclesEvent(data) {
+        const horizontal = matchesKey(data, 'right') || matchesKey(data, 'left');
+        if (matchesKey(data, 'tab') || (!horizontal && this.matches('crtr.setup.tab-next', data)))
+            return 1;
+        if (matchesKey(data, 'shift+tab') || (!horizontal && this.matches('crtr.setup.tab-previous', data)))
+            return -1;
+        return 0;
+    }
+    handleInput(data) {
+        if (this.busy !== undefined)
+            return;
+        if (this.modal !== undefined) {
+            this.handleModal(data);
+            return;
+        }
+        if (this.docs.ownsKeyboard && this.docs.handleInput(data)) {
+            this.syncDetail();
+            return;
+        }
+        const step = this.cyclesEvent(data);
+        if (step !== 0) {
+            this.setSnapshot(cycleAxis(this.snapshot, 'event', step));
+            return;
+        }
+        if (matchesKey(data, 'q') || this.matches('crtr.setup.cancel', data)) {
+            this.close();
+            return;
+        }
+        if (this.zone === 'axes')
+            this.handleAxes(data);
+        else if (this.zone === 'docs')
+            this.handleDocs(data);
+        else
+            this.handleDetail(data);
+    }
+    handleAxes(data) {
+        const axes = axesOf(this.snapshot, profileNameFor(this.snapshot.profileId) ?? 'none');
+        this.axisIndex = Math.max(0, Math.min(this.axisIndex, axes.length - 1));
+        const axis = axes[this.axisIndex];
+        if (this.isDown(data)) {
+            this.axisIndex = Math.min(axes.length - 1, this.axisIndex + 1);
+        }
+        else if (this.isUp(data)) {
+            this.axisIndex = Math.max(0, this.axisIndex - 1);
+        }
+        else if (matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
+            if (axis.typed)
+                this.openAxisField(axis.id, axis.label);
+            else
+                this.setSnapshot(cycleAxis(this.snapshot, axis.id, 1));
+        }
+        else if (this.isDescend(data)) {
+            if (matchesKey(data, 'enter') && axis.typed)
+                this.openAxisField(axis.id, axis.label);
+            else
+                this.zone = 'docs';
+        }
+        else if (matchesKey(data, 'escape')) {
+            this.close();
+        }
+    }
+    handleDocs(data) {
+        if (this.docs.handleInput(data)) {
+            this.syncDetail();
+            return;
+        }
+        if (this.isDown(data)) {
+            this.docs.move(1);
+            this.syncDetail();
+        }
+        else if (this.isUp(data)) {
+            this.docs.move(-1);
+            this.syncDetail();
+        }
+        else if (matchesKey(data, 'd')) {
+            this.docs.toggleDeliveringOnly();
+            this.syncDetail();
+        }
+        else if (this.isDescend(data)) {
+            if (this.docs.selected !== undefined)
+                this.zone = 'detail';
+        }
+        else if (this.isAscend(data) || matchesKey(data, 'escape')) {
+            this.zone = 'axes';
+        }
+    }
+    handleDetail(data) {
+        if (this.isDown(data))
+            this.detail.move(1);
+        else if (this.isUp(data))
+            this.detail.move(-1);
+        else if (this.isAscend(data) || matchesKey(data, 'escape'))
+            this.zone = 'docs';
+        else if (matchesKey(data, 'enter') || matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
+            this.activate();
+        }
+        else if (matchesKey(data, 'b'))
+            this.editBody();
+        else if (matchesKey(data, 'x'))
+            this.removeEntry();
+        else if (matchesKey(data, 'e'))
+            this.composeEntry();
+        else if (matchesKey(data, 'g'))
+            this.editGate();
+        else if (matchesKey(data, 'u'))
+            this.flip('unlisted');
+        else if (matchesKey(data, 's'))
+            this.flip('slash');
+        else if (matchesKey(data, 'm'))
+            this.editCap();
+        else if (matchesKey(data, 'r'))
+            this.editMove();
+        else if (matchesKey(data, 'w'))
+            this.editRouting();
+        else if (matchesKey(data, 'f'))
+            this.editShortForm();
+    }
+    /** What the focused dossier row does when opened — the same write its letter
+     *  key starts, so a user who never learns the letters can still edit. */
+    activate() {
+        const row = this.detail.selected;
+        if (row === undefined)
+            return;
+        switch (row.kind) {
+            case 'entry': return this.cycleEntryRung(row.at);
+            case 'add-entry': return this.composeEntry();
+            case 'gate': return this.editGate();
+            case 'unlisted': return this.flip('unlisted');
+            case 'slash': return this.flip('slash');
+            case 'routing': return this.editRouting();
+            case 'short-form': return this.editShortForm();
+            case 'body': return this.editBody();
+            case 'cap': return this.editCap();
+            case 'move': return this.editMove();
+        }
+    }
+    // writes
+    get record() {
+        return this.docs.selected?.anchor;
+    }
+    apply(work) {
+        this.busy = 'writing…';
+        this.tui.requestRender();
+        void work.then((outcome) => {
+            this.busy = undefined;
+            this.notice = { text: outcome.message, ok: outcome.ok };
+            if (outcome.ok) {
+                if (outcome.name !== undefined)
+                    this.edited.add(outcome.name);
+                this.plans.invalidate();
+                this.rebuild();
+            }
+            this.tui.requestRender();
+        });
+    }
+    cycleEntryRung(at) {
+        const record = this.record;
+        const entry = record?.doc.surfaces[at];
+        if (record === undefined || entry === undefined)
+            return;
+        const next = SURFACE_RUNGS[(SURFACE_RUNGS.indexOf(entry.at) + 1) % SURFACE_RUNGS.length];
+        const surfaces = record.doc.surfaces.map((held, index) => (index === at ? { ...held, at: next } : held));
+        this.apply(writeSurfaces(record, this.snapshot.profileId, surfaces, `${record.name} now delivers at "${next}" on ${entry.on}.`));
+    }
+    removeEntry() {
+        const record = this.record;
+        const at = this.detail.selectedEntry;
+        if (record === undefined || at === undefined) {
+            this.notice = { text: 'Select a surface entry to remove.', ok: false };
+            return;
+        }
+        const entry = record.doc.surfaces[at];
+        const surfaces = record.doc.surfaces.filter((_held, index) => index !== at);
+        this.modal = {
+            kind: 'confirm',
+            title: 'Remove surface entry',
+            message: `${record.name} will stop delivering on ${entry.on} at "${entry.at}".`,
+            submit: () => this.apply(writeSurfaces(record, this.snapshot.profileId, surfaces, `Removed the ${entry.on} entry from ${record.name}.`)),
+        };
+    }
+    /** Event, then match, then rung — the three fields a valid entry needs, asked
+     *  in the order the schema reads them. */
+    composeEntry() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'choice',
+            title: 'New entry — event',
+            options: [...SURFACE_EVENTS],
+            index: SURFACE_EVENTS.indexOf(this.snapshot.event),
+            submit: (event) => {
+                const on = event;
+                const needsMatch = on !== 'boot' && on !== 'workspace-open';
+                const chooseRung = (match) => {
+                    this.modal = {
+                        kind: 'choice',
+                        title: 'New entry — rung',
+                        options: [...SURFACE_RUNGS],
+                        index: 0,
+                        submit: (rung) => {
+                            this.modal = undefined;
+                            const entry = {
+                                on,
+                                ...(match === '' ? {} : { match: [match] }),
+                                at: rung,
+                            };
+                            this.apply(writeSurfaces(record, this.snapshot.profileId, [...record.doc.surfaces, entry], `${record.name} now delivers on ${on} at "${rung}".`));
+                        },
+                    };
+                };
+                if (!needsMatch) {
+                    chooseRung('');
+                    return;
+                }
+                this.modal = {
+                    kind: 'field',
+                    title: `New entry — ${on} match`,
+                    hint: on === 'read' ? 'absolute path glob, or ./ for this document\u2019s own directory' : 'glob over the event\u2019s namespace',
+                    input: seeded(''),
+                    submit: (value) => {
+                        const match = value.trim();
+                        if (match === '') {
+                            this.modal = undefined;
+                            this.notice = { text: `A ${on} entry needs a match glob.`, ok: false };
+                            return;
+                        }
+                        chooseRung(match);
+                    },
+                };
+            },
+        };
+    }
+    editGate() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'field',
+            title: 'Document gate',
+            hint: 'YAML or JSON predicate over the node config — empty clears it',
+            input: seeded(record.doc.gate === undefined ? '' : JSON.stringify(record.doc.gate)),
+            submit: (value) => {
+                this.modal = undefined;
+                this.apply(writeGate(record, this.snapshot.profileId, value));
+            },
+        };
+    }
+    flip(field) {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.apply(toggleFlag(record, this.snapshot.profileId, field));
+    }
+    editRouting() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'field',
+            title: 'Routing line',
+            hint: 'When <circumstance>, this <kind> should be read because <payoff>',
+            input: seeded(record.doc.whenAndWhyToRead),
+            submit: (value) => {
+                this.modal = undefined;
+                this.apply(writeRoutingLine(record, this.snapshot.profileId, value));
+            },
+        };
+    }
+    editShortForm() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'field',
+            title: 'Short form',
+            hint: 'human-facing abbreviation for listings — empty clears it',
+            input: seeded(record.doc.shortForm),
+            submit: (value) => {
+                this.modal = undefined;
+                this.apply(writeShortForm(record, this.snapshot.profileId, value));
+            },
+        };
+    }
+    /** The one write that leaves the page: the terminal goes to $EDITOR and comes
+     *  back repainted, and the buffer that returns is saved through `memory edit`
+     *  like every other field here. */
+    editBody() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        // Checked before the terminal leaves for $EDITOR, so a read-only record
+        // refuses in place rather than after a whole editing session.
+        const refusal = readOnlyReason(record, this.snapshot.profileId);
+        if (refusal !== null) {
+            this.notice = { text: refusal, ok: false };
+            return;
+        }
+        let before;
+        try {
+            before = readBody(record);
+        }
+        catch (error) {
+            this.notice = { text: error instanceof Error ? error.message : String(error), ok: false };
+            return;
+        }
+        const resume = this.suspendForChild();
+        let result;
+        try {
+            result = editBufferInEditor(before);
+        }
+        finally {
+            resume();
+        }
+        if (result.error !== undefined) {
+            this.notice = { text: result.error, ok: false };
+            return;
+        }
+        if (result.text === before) {
+            this.notice = { text: `${record.name} came back unchanged \u2014 nothing written.`, ok: false };
+            return;
+        }
+        this.apply(writeBody(record, this.snapshot.profileId, result.text));
+    }
+    editMove() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'field',
+            title: 'Move or rename',
+            hint: 'the new canonical name inside this document\u2019s own store',
+            input: seeded(record.name),
+            submit: (value) => {
+                this.modal = undefined;
+                this.apply(moveDoc(record, this.snapshot.profileId, value));
+            },
+        };
+    }
+    /** The ceiling belongs to the profile project entry that governs the store,
+     *  not to the document, so this write is offered only when one exists. */
+    editCap() {
+        const record = this.record;
+        const profileId = this.snapshot.profileId;
+        if (record === undefined)
+            return;
+        const owner = profileId === null ? null : capOwnerFor(record, profileId);
+        if (owner === null || profileId === null) {
+            this.notice = { text: 'No profile project governs this store — its ceiling is neutral and not editable here.', ok: false };
+            return;
+        }
+        this.modal = {
+            kind: 'choice',
+            title: `Ceiling for ${owner.path}`,
+            options: [...RUNGS],
+            index: Math.max(0, RUNGS.indexOf(owner.memory)),
+            submit: (rung) => {
+                this.modal = undefined;
+                const outcome = writeCap(profileId, owner.path, rung);
+                this.notice = { text: outcome.message, ok: outcome.ok };
+                if (outcome.change !== undefined) {
+                    const held = this.capChanges.findIndex((change) => change.path === outcome.change.path);
+                    if (held >= 0)
+                        this.capChanges[held] = outcome.change;
+                    else
+                        this.capChanges.push(outcome.change);
+                    this.plans.invalidate();
+                    this.rebuild();
+                }
+            },
+        };
+    }
+    openAxisField(id, label) {
+        this.modal = {
+            kind: 'field',
+            title: label,
+            hint: id === 'cwd' ? 'absolute directory the project stores resolve from' : 'value the planner should match against',
+            input: seeded(typedAxisValue(this.snapshot, id)),
+            submit: (value) => {
+                this.modal = undefined;
+                this.setSnapshot(setTypedAxis(this.snapshot, id, value));
+            },
+        };
+    }
+    close() {
+        if (this.edited.size === 0 && this.capChanges.length === 0) {
+            this.onCancel?.();
+            return;
+        }
+        this.onSubmit?.({ edited: [...this.edited], capChanges: [...this.capChanges] });
+    }
+    // modals
+    handleModal(data) {
+        const modal = this.modal;
+        if (modal === undefined)
+            return;
+        if (matchesKey(data, 'escape')) {
+            this.modal = undefined;
+            return;
+        }
+        if (modal.kind === 'choice') {
+            if (this.isDown(data))
+                modal.index = Math.min(modal.options.length - 1, modal.index + 1);
+            else if (this.isUp(data))
+                modal.index = Math.max(0, modal.index - 1);
+            else if (matchesKey(data, 'enter'))
+                modal.submit(modal.options[modal.index]);
+            return;
+        }
+        if (modal.kind === 'confirm') {
+            if (matchesKey(data, 'y') || matchesKey(data, 'enter')) {
+                this.modal = undefined;
+                modal.submit();
+            }
+            else if (matchesKey(data, 'n'))
+                this.modal = undefined;
+            return;
+        }
+        if (matchesKey(data, 'enter'))
+            modal.submit(modal.input.getValue());
+        else
+            modal.input.handleInput(data);
+    }
+    renderModal(width, height) {
+        const modal = this.modal;
+        if (modal === undefined)
+            return [];
+        let lines;
+        if (modal.kind === 'choice') {
+            lines = [
+                theme.fg('accent', theme.bold(modal.title)),
+                '',
+                ...modal.options.map((option, index) => `${index === modal.index ? theme.fg('accent', '▶') : ' '} ${option}`),
+            ];
+        }
+        else if (modal.kind === 'confirm') {
+            lines = [theme.fg('warning', theme.bold(modal.title)), '', ...wrap(modal.message, Math.max(1, width - 6))];
+        }
+        else {
+            lines = [
+                theme.fg('accent', theme.bold(modal.title)),
+                theme.fg('dim', modal.hint),
+                '',
+                modal.input.render(Math.max(1, width - 6))[0] ?? '',
+            ];
+        }
+        const out = framed(lines, width);
+        while (out.length < height)
+            out.push('');
+        return out.slice(0, height);
+    }
+    // rendering
+    footer(width) {
+        if (this.busy !== undefined)
+            return theme.fg('warning', this.busy);
+        if (this.modal?.kind === 'choice')
+            return theme.fg('dim', 'j/k choose · enter apply · esc cancel');
+        if (this.modal?.kind === 'confirm')
+            return theme.fg('dim', 'y/enter confirm · n/esc cancel');
+        if (this.modal?.kind === 'field')
+            return theme.fg('dim', 'type · enter apply · esc cancel');
+        if (this.docs.ownsKeyboard)
+            return theme.fg('dim', 'type to filter · enter keep · esc clear');
+        if (this.notice !== undefined)
+            return theme.fg(this.notice.ok ? 'success' : 'warning', truncateToWidth(this.notice.text, width));
+        const move = `${this.label('crtr.setup.list-down', 'j')}/${this.label('crtr.setup.list-up', 'k')}`;
+        const left = this.zone === 'axes'
+            ? `${move} axis · space change · enter documents`
+            : this.zone === 'docs'
+                ? `${move} doc · / filter · d ${this.docs.filteringDelivering ? 'all' : 'delivering'} · enter dossier`
+                : `${move} field · enter edit · e add · x remove · g gate · b body · u unlisted · s slash · m cap · r rename`;
+        const right = `${this.label('crtr.setup.tab-next', 'tab')} event · ${this.label('crtr.setup.cancel', 'q')} close`;
+        const gap = width - visibleWidth(left) - visibleWidth(right);
+        return gap >= 2
+            ? `${theme.fg('dim', left)}${' '.repeat(gap)}${theme.fg('dim', right)}`
+            : theme.fg('dim', truncateToWidth(`${left} · ${this.label('crtr.setup.cancel', 'q')} close`, width));
+    }
+    render(width) {
+        const height = this.terminalRows();
+        const bodyHeight = Math.max(1, height - PAGE_CHROME_ROWS);
+        const railVisible = width >= RAIL_MIN_TOTAL_WIDTH;
+        const axes = axesOf(this.snapshot, profileNameFor(this.snapshot.profileId) ?? 'none');
+        this.axisIndex = Math.max(0, Math.min(this.axisIndex, axes.length - 1));
+        let body;
+        if (width >= THREE_COLUMN_MIN_WIDTH) {
+            const detailWidth = Math.max(1, width - RAIL_WIDTH - DOCS_WIDTH - 6);
+            const middle = columns(this.docs.render(DOCS_WIDTH, bodyHeight, this.zone === 'docs', this.plans), DOCS_WIDTH, this.modal === undefined
+                ? this.detail.render(detailWidth, bodyHeight, this.zone === 'detail')
+                : this.renderModal(detailWidth, bodyHeight), detailWidth);
+            body = columns(renderAxes(axes, this.axisIndex, RAIL_WIDTH, bodyHeight, this.zone === 'axes'), RAIL_WIDTH, middle, width - RAIL_WIDTH - 3);
+        }
+        else if (railVisible) {
+            const panelWidth = width - RAIL_WIDTH - 3;
+            const panel = this.modal !== undefined
+                ? this.renderModal(panelWidth, bodyHeight)
+                : this.zone === 'detail'
+                    ? this.detail.render(panelWidth, bodyHeight, true)
+                    : this.docs.render(panelWidth, bodyHeight, this.zone === 'docs', this.plans);
+            body = columns(renderAxes(axes, this.axisIndex, RAIL_WIDTH, bodyHeight, this.zone === 'axes'), RAIL_WIDTH, panel, panelWidth);
+        }
+        else if (this.modal !== undefined) {
+            body = this.renderModal(width, bodyHeight);
+        }
+        else if (this.zone === 'axes') {
+            body = renderAxes(axes, this.axisIndex, width, bodyHeight, true);
+        }
+        else if (this.zone === 'detail') {
+            body = this.detail.render(width, bodyHeight, true);
+        }
+        else {
+            body = this.docs.render(width, bodyHeight, true, this.plans);
+        }
+        const pending = SURFACE_EVENTS.filter((event) => this.plans.peek(event) === undefined).length;
+        const meta = [
+            this.snapshot.event,
+            pending > 0 ? `${plural(pending, 'event', 'events')} planning` : 'all events planned',
+            this.edited.size > 0 ? `${plural(this.edited.size, 'doc', 'docs')} edited` : '',
+        ]
+            .filter((part) => part !== '')
+            .join(' · ');
+        return pageFrame({ width, height, title: 'crouter context', meta, body, footer: this.footer(width) });
+    }
+}
+/** Every field here is an edit-or-accept, never a blank to retype, so the
+ *  cursor lands at the end (`\x05`) — `setValue` alone leaves it at 0, where
+ *  typing prepends and backspace does nothing. */
+function seeded(value) {
+    const input = new Input();
+    input.setValue(value);
+    input.handleInput('\x05');
+    input.focused = true;
+    return input;
+}
+function wrap(text, width) {
+    const out = [];
+    let line = '';
+    for (const word of text.trim().split(/\s+/)) {
+        const next = line === '' ? word : `${line} ${word}`;
+        if (visibleWidth(next) <= width)
+            line = next;
+        else {
+            if (line !== '')
+                out.push(line);
+            line = word;
+        }
+    }
+    if (line !== '')
+        out.push(line);
+    return out;
+}
+export async function runContextAdmin(seed) {
+    return runTuiPage(({ tui, terminal, bindings, suspendForChild }, control) => {
+        const shell = new ContextAdminShell(seed, tui, () => terminal.rows, bindings, suspendForChild);
+        shell.onCancel = control.cancel;
+        shell.onSubmit = control.submit;
+        return shell;
+    });
+}

package/dist/commands/sys/context/admin.d.ts

@@ -0,0 +1 @@
+export declare const adminLeaf: import("../../../core/command.js").LeafDef;