@north-light/api 0.3.580 → 0.3.587

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

@@ -0,0 +1,870 @@
+// The `crtr sys context admin` page: a rail, the document list, and the dossier
+// that edits one document's routing. The rail decides WHAT is being planned and
+// WHICH slice of it is shown, the list states what each document does on the
+// dialled event, 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 { writeClipboardTextEverywhere } from '../../../../core/clipboard-text.js';
+import { runTuiPage } from '../../../../core/tui/page-host.js';
+import { PAGE_CHROME_ROWS, columns, framed, pageFrame, theme, } from '../../../../core/tui/panel.js';
+import { editBufferInEditor } from '../../../../clients/inbox/review/roundtrip.js';
+import { PLANNED_EVENTS } from '../resolve.js';
+import { moveDoc, readBody, readOnlyReason, toggleUnlisted, writeBody, writePreview, writeRules, } from './actions.js';
+import { axesOf, cycleAxis, cycleFacet, facetsOf, payloadRowOf, railEnter, railRowKey, railRowsOf, renderRail, setTypedAxis, typedAxisValue, } from './rail-panel.js';
+import { ContextDetailPanel } from './detail-panel.js';
+import { ContextDocsPanel, buildRows } from './docs-panel.js';
+import { NO_FILTERS } from './list-view.js';
+import { DELIVER_LEVELS, PlanSet, describeRule, plural } from './model.js';
+/** Activities whose rules need a `match` glob — every one but the two that
+ *  fire once per node. */
+function needsMatch(on) {
+    return on !== 'boot' && on !== 'workspace-open';
+}
+const MATCH_HINTS = {
+    boot: '',
+    'workspace-open': '',
+    'file-read': 'absolute path glob, or ./ for this document\u2019s own directory',
+    'document-read': 'document name glob',
+    command: 'command-path glob, e.g. node new',
+    'pre-command': 'command-path glob, e.g. node new',
+    'slash-command': 'slash command name glob',
+};
+const RAIL_WIDTH = 26;
+const RAIL_MIN_TOTAL_WIDTH = 86;
+const THREE_COLUMN_MIN_WIDTH = 112;
+/** Columns the two dividers between the three zones spend. */
+const DIVIDER_WIDTH = 6;
+/** Below the floor a row cannot hold a name beside its state; above the ceiling
+ *  extra width stops buying legibility and the dossier wants it. */
+const DOCS_MIN_WIDTH = 48;
+const DOCS_MAX_WIDTH = 100;
+const DOCS_SHARE = 0.45;
+/** The list's share of what is left after the rail and the dividers. */
+function docsWidthFor(width) {
+    const room = Math.max(1, width - RAIL_WIDTH - DIVIDER_WIDTH);
+    return Math.max(DOCS_MIN_WIDTH, Math.min(DOCS_MAX_WIDTH, Math.floor(room * DOCS_SHARE)));
+}
+export class ContextAdminShell {
+    tui;
+    terminalRows;
+    bindings;
+    suspendForChild;
+    profiles;
+    snapshot;
+    plans;
+    zone = 'rail';
+    railIndex = 0;
+    filters = NO_FILTERS;
+    rows = [];
+    /** The search field owns the keyboard while it is open. */
+    searching = false;
+    docs;
+    detail = new ContextDetailPanel();
+    modal;
+    notice;
+    busy;
+    edited = new Set();
+    /** Bodies the reader opened, by object id — the plan carries none. */
+    bodies = new Map();
+    _focused = false;
+    onCancel;
+    onSubmit;
+    constructor(seed, tui, terminalRows, bindings, suspendForChild, profiles) {
+        this.tui = tui;
+        this.terminalRows = terminalRows;
+        this.bindings = bindings;
+        this.suspendForChild = suspendForChild;
+        this.profiles = profiles;
+        this.snapshot = seed;
+        this.plans = new PlanSet(seed, () => {
+            this.refreshRows();
+            this.tui.requestRender();
+        });
+        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() {
+        this.refreshRows();
+        this.plans.warm(this.snapshot.event);
+    }
+    refreshRows() {
+        this.rows = buildRows(this.plans, this.snapshot.event);
+        this.docs.setRows(this.rows, this.snapshot.event);
+        this.syncDetail();
+    }
+    /** A filter never re-plans: it is a question about the plan already computed,
+     *  which is what keeps a facet change instant on a corpus this size. */
+    setFilters(next) {
+        this.filters = next;
+        this.docs.setFilters(next);
+        this.syncDetail();
+    }
+    syncDetail() {
+        const row = this.docs.selected;
+        const readOnly = row === undefined ? null : readOnlyReason(row.anchor);
+        // The plan's own subject, not a re-derived one: what a failed gate is
+        // explained against must be exactly what it was judged against.
+        const subject = this.plans.peek(this.snapshot.event)?.subject ?? null;
+        this.detail.setContext(row, this.snapshot.event, readOnly, subject, row === undefined ? undefined : this.bodies.get(row.key));
+    }
+    setSnapshot(next) {
+        const held = this.railRows()[this.railIndex];
+        this.snapshot = next;
+        this.plans.setSnapshot(next);
+        this.notice = undefined;
+        this.rebuild();
+        this.holdRail(held);
+    }
+    /** Put the rail cursor back on the row it was on, since dialling a different
+     *  event moves the payload row and every offset below it. The payload belongs
+     *  to the dialled event, so when the new event reads none the cursor falls to
+     *  that event's own row rather than to whatever slid into the offset. */
+    holdRail(held) {
+        if (held === undefined)
+            return;
+        const rows = this.railRows();
+        const key = railRowKey(held);
+        const at = rows.findIndex((row) => railRowKey(row) === key);
+        this.railIndex = Math.max(0, at >= 0 ? at : rows.findIndex((row) => row.kind === 'event' && row.event.dialled));
+    }
+    // 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.searching) {
+            this.handleSearch(data);
+            return;
+        }
+        const step = this.cyclesEvent(data);
+        if (step !== 0) {
+            this.setSnapshot(cycleAxis(this.snapshot, 'event', step, this.profiles));
+            return;
+        }
+        // `crtr.setup.cancel` also claims ctrl+d, so the read face's half-pane
+        // gesture has to outrank it or paging a body would close the page instead.
+        const pagesBody = this.zone === 'detail' && !this.detail.editing && matchesKey(data, 'ctrl+d');
+        if (!pagesBody && (matchesKey(data, 'q') || this.matches('crtr.setup.cancel', data))) {
+            this.close();
+            return;
+        }
+        if (this.zone === 'rail')
+            this.handleRail(data);
+        else if (this.zone === 'docs')
+            this.handleDocs(data);
+        else
+            this.handleDetail(data);
+    }
+    /** Every surface event with what it delivers, which is what the rail states
+     *  instead of the list drawing a cell per event on every row. An event whose
+     *  plan has not warmed yet has no count to state. */
+    eventRows() {
+        return PLANNED_EVENTS.map((event) => {
+            const plan = this.plans.peek(event);
+            return {
+                event,
+                delivers: plan === undefined ? undefined : plan.docs.filter((record) => record.finalRung !== 'none').length,
+                dialled: event === this.snapshot.event,
+            };
+        });
+    }
+    /** The rail's rows: the events, then the snapshot axes, then the filter
+     *  facets, so one cursor and one gesture drive all three sections. */
+    railRows() {
+        return railRowsOf(this.eventRows(), payloadRowOf(this.snapshot), axesOf(this.snapshot, this.profileName()), facetsOf(this.filters));
+    }
+    profileName() {
+        const id = this.snapshot.profileId;
+        if (id === null)
+            return 'none';
+        return this.profiles.find((profile) => profile.id === id)?.name ?? id;
+    }
+    handleRail(data) {
+        const rows = this.railRows();
+        this.railIndex = Math.max(0, Math.min(this.railIndex, rows.length - 1));
+        const row = rows[this.railIndex];
+        const change = (delta) => {
+            if (row === undefined)
+                return;
+            if (row.kind === 'event')
+                this.setSnapshot({ ...this.snapshot, event: row.event.event });
+            else if (row.kind === 'axis') {
+                if (row.axis.typed)
+                    this.openAxisField(row.axis.id, row.axis.label);
+                else
+                    this.setSnapshot(cycleAxis(this.snapshot, row.axis.id, delta, this.profiles));
+            }
+            else if (row.facet.typed)
+                this.openSearch();
+            else
+                this.setFilters(cycleFacet(this.filters, row.facet.id, delta));
+        };
+        const onEnter = railEnter(row);
+        if (this.isDown(data)) {
+            this.railIndex = Math.min(rows.length - 1, this.railIndex + 1);
+        }
+        else if (this.isUp(data)) {
+            this.railIndex = Math.max(0, this.railIndex - 1);
+        }
+        else if (matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
+            change(1);
+        }
+        else if (this.isDescend(data)) {
+            if (matchesKey(data, 'enter') && onEnter !== 'documents')
+                change(1);
+            else
+                this.zone = 'docs';
+        }
+        else if (matchesKey(data, 'escape')) {
+            this.close();
+        }
+    }
+    handleDocs(data) {
+        if (data === '/' || matchesKey(data, '/')) {
+            this.openSearch();
+        }
+        else if (matchesKey(data, 'y')) {
+            this.yankId();
+        }
+        else 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, 'space') || this.matches('crtr.setup.toggle', data)) {
+            this.docs.toggleGroup();
+            this.syncDetail();
+        }
+        else if (this.isDescend(data)) {
+            // One gesture per row: a header expands, a document opens its dossier.
+            if (this.docs.onGroup) {
+                this.docs.toggleGroup();
+                this.syncDetail();
+            }
+            else if (this.docs.selected !== undefined)
+                this.zone = 'detail';
+        }
+        else if (matchesKey(data, 'escape') && this.filters.query !== '') {
+            this.setFilters({ ...this.filters, query: '' });
+        }
+        else if (this.isAscend(data) || matchesKey(data, 'escape')) {
+            this.zone = 'rail';
+        }
+    }
+    openSearch() {
+        this.searching = true;
+        this.zone = 'docs';
+        this.tui.requestRender();
+    }
+    /** Typing filters live, so the field is the list's own heading rather than a
+     *  modal over the rows it is selecting. */
+    handleSearch(data) {
+        if (matchesKey(data, 'escape')) {
+            this.searching = false;
+            this.setFilters({ ...this.filters, query: '' });
+        }
+        else if (matchesKey(data, 'enter')) {
+            this.searching = false;
+        }
+        else if (matchesKey(data, 'backspace')) {
+            this.setFilters({ ...this.filters, query: this.filters.query.slice(0, -1) });
+        }
+        else if (data.length === 1 && data.charCodeAt(0) >= 32) {
+            this.setFilters({ ...this.filters, query: this.filters.query + data });
+        }
+        this.tui.requestRender();
+    }
+    handleDetail(data) {
+        if (matchesKey(data, 'y'))
+            this.yankId();
+        else if (this.detail.editing)
+            this.handleEdit(data);
+        else
+            this.handleRead(data);
+    }
+    /** Put the focused document's object id on the clipboard, so a reader who
+     *  spotted the document that is misbehaving can read, edit, or pass it along
+     *  (`crtr canvas read <id>`) without retyping it off the screen. */
+    yankId() {
+        const row = this.docs.selected;
+        if (row === undefined)
+            return;
+        const { system, tmux } = writeClipboardTextEverywhere(row.key);
+        this.notice =
+            system || tmux
+                ? { text: `Copied ${row.key}${system ? '' : ' to the tmux buffer'}`, ok: true }
+                : { text: 'No clipboard tool available — nothing copied', ok: false };
+        this.tui.requestRender();
+    }
+    /** The resting face: reading, and the two gestures that leave it. */
+    handleRead(data) {
+        if (this.isDown(data))
+            this.detail.move(1);
+        else if (this.isUp(data))
+            this.detail.move(-1);
+        else if (matchesKey(data, 'ctrl+d'))
+            this.detail.page(1);
+        else if (matchesKey(data, 'ctrl+u'))
+            this.detail.page(-1);
+        else if (data === 'G' || matchesKey(data, 'shift+g'))
+            this.detail.jump('bottom');
+        else if (data === 'g' || matchesKey(data, 'g'))
+            this.detail.jump('top');
+        else if (data === 'e' || matchesKey(data, 'e'))
+            this.detail.edit();
+        else if (this.isDescend(data))
+            this.openBody();
+        else if (this.isAscend(data) || matchesKey(data, 'escape')) {
+            if (!this.detail.back())
+                this.zone = 'docs';
+        }
+    }
+    /** Open the body in place, fetching it the first time it is opened. */
+    openBody() {
+        const row = this.docs.selected;
+        if (row === undefined || !this.detail.openBody())
+            return;
+        if (this.bodies.has(row.key))
+            return;
+        const key = row.key;
+        void readBody(row.anchor.doc).then((body) => {
+            this.bodies.set(key, body);
+            this.syncDetail();
+            this.tui.requestRender();
+        }, (error) => {
+            this.notice = { text: error instanceof Error ? error.message : String(error), ok: false };
+            this.detail.back();
+            this.tui.requestRender();
+        });
+    }
+    /** The field list. Every write gesture is resolved before it is started, so a
+     *  read-only document refuses at the keypress rather than after a modal. */
+    handleEdit(data) {
+        if (this.isDown(data)) {
+            this.detail.move(1);
+            return;
+        }
+        if (this.isUp(data)) {
+            this.detail.move(-1);
+            return;
+        }
+        if (this.isAscend(data) || matchesKey(data, 'escape')) {
+            this.detail.back();
+            return;
+        }
+        const gesture = this.writeGesture(data);
+        if (gesture === undefined)
+            return;
+        if (gesture.document && this.refusesWrite())
+            return;
+        gesture.start();
+    }
+    /** The write one edit-face key starts, or undefined when the key writes
+     *  nothing. `document` marks the writes a read-only document refuses — the
+     *  delivery limit is not one of them; it lives on the profile. */
+    writeGesture(data) {
+        const doc = (start) => ({ start, document: true });
+        if (matchesKey(data, 'enter') || matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
+            const row = this.detail.selected;
+            if (row === undefined)
+                return undefined;
+            return doc(() => this.activate());
+        }
+        if (matchesKey(data, 'm'))
+            return { start: () => this.explainLimit(), document: false };
+        if (matchesKey(data, 'b'))
+            return doc(() => this.editBody());
+        if (matchesKey(data, 'x'))
+            return doc(() => this.removeRule());
+        if (matchesKey(data, 'e'))
+            return doc(() => this.composeRule());
+        if (matchesKey(data, 'u'))
+            return doc(() => this.flipUnlisted());
+        if (matchesKey(data, 'r'))
+            return doc(() => this.editMove());
+        if (matchesKey(data, 'w'))
+            return doc(() => this.editPreview());
+        return undefined;
+    }
+    /** The refusal a read-only document owes the write just attempted, carried by
+     *  the same footer channel every other write outcome uses. */
+    refusesWrite() {
+        const record = this.record;
+        if (record === undefined)
+            return false;
+        const refusal = readOnlyReason(record);
+        if (refusal === null)
+            return false;
+        this.notice = { text: refusal, ok: false };
+        this.tui.requestRender();
+        return true;
+    }
+    /** 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 'rule': return this.cycleRuleLevel(row.at);
+            case 'add-rule': return this.composeRule();
+            case 'preview': return this.editPreview();
+            case 'unlisted': return this.flipUnlisted();
+            case 'body': return this.editBody();
+            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.bodies.clear();
+                this.plans.refresh();
+                this.rebuild();
+            }
+            this.tui.requestRender();
+        });
+    }
+    cycleRuleLevel(at) {
+        const record = this.record;
+        const rule = record?.doc.rules[at];
+        if (record === undefined || rule === undefined)
+            return;
+        const levels = DELIVER_LEVELS;
+        const next = DELIVER_LEVELS[(levels.indexOf(rule.deliver) + 1) % DELIVER_LEVELS.length];
+        const rules = record.doc.rules.map((held, index) => (index === at ? { ...held, deliver: next } : held));
+        this.apply(writeRules(record, rules, `${record.doc.displayName} now delivers ${next} on ${rule.on}.`));
+    }
+    removeRule() {
+        const record = this.record;
+        const at = this.detail.selectedRule;
+        if (record === undefined || at === undefined) {
+            this.notice = { text: 'Select a delivery rule to remove.', ok: false };
+            return;
+        }
+        const rule = record.doc.rules[at];
+        const rules = record.doc.rules.filter((_held, index) => index !== at);
+        this.modal = {
+            kind: 'confirm',
+            title: 'Remove delivery rule',
+            message: `${record.doc.displayName} will stop delivering on ${rule.on} (${describeRule(rule)}).`,
+            submit: () => this.apply(writeRules(record, rules, `Removed the ${rule.on} rule from ${record.doc.displayName}.`)),
+        };
+    }
+    /** Activity, then match, then level — the three fields a valid rule needs,
+     *  asked in the order the rule reads them. */
+    composeRule() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'choice',
+            title: 'New rule \u2014 activity',
+            options: [...PLANNED_EVENTS],
+            index: PLANNED_EVENTS.indexOf(this.snapshot.event),
+            submit: (event) => {
+                const on = event;
+                const chooseLevel = (match) => {
+                    this.modal = {
+                        kind: 'choice',
+                        title: 'New rule \u2014 deliver',
+                        options: [...DELIVER_LEVELS],
+                        index: 0,
+                        submit: (level) => {
+                            this.modal = undefined;
+                            const rule = { on, ...(match === '' ? {} : { match: [match] }), deliver: level };
+                            this.apply(writeRules(record, [...record.doc.rules, rule], `${record.doc.displayName} now delivers ${level} on ${on}.`));
+                        },
+                    };
+                };
+                if (!needsMatch(on)) {
+                    chooseLevel('');
+                    return;
+                }
+                this.modal = {
+                    kind: 'field',
+                    title: `New rule \u2014 ${on} match`,
+                    hint: MATCH_HINTS[on],
+                    input: seeded(''),
+                    submit: (value) => {
+                        const match = value.trim();
+                        if (match === '') {
+                            this.modal = undefined;
+                            this.notice = { text: `A ${on} rule needs a match glob.`, ok: false };
+                            return;
+                        }
+                        chooseLevel(match);
+                    },
+                };
+            },
+        };
+    }
+    flipUnlisted() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.apply(toggleUnlisted(record));
+    }
+    editPreview() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'field',
+            title: 'Preview',
+            hint: 'the one line a reader decides to open the document on',
+            input: seeded(record.doc.preview),
+            submit: (value) => {
+                this.modal = undefined;
+                this.apply(writePreview(record, 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 the same
+     *  route `crtr doc edit` uses. */
+    editBody() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.busy = 'reading the body\u2026';
+        this.tui.requestRender();
+        void readBody(record.doc).then((before) => {
+            this.busy = undefined;
+            const resume = this.suspendForChild();
+            let result;
+            try {
+                result = editBufferInEditor(before);
+            }
+            finally {
+                resume();
+            }
+            if (result.error !== undefined) {
+                this.notice = { text: result.error, ok: false };
+            }
+            else if (result.text === before) {
+                this.notice = { text: `${record.doc.displayName} came back unchanged \u2014 nothing written.`, ok: false };
+            }
+            else {
+                this.apply(writeBody(record, result.text));
+                return;
+            }
+            this.tui.requestRender();
+        }, (error) => {
+            this.busy = undefined;
+            this.notice = { text: error instanceof Error ? error.message : String(error), ok: false };
+            this.tui.requestRender();
+        });
+    }
+    editMove() {
+        const record = this.record;
+        if (record === undefined)
+            return;
+        this.modal = {
+            kind: 'field',
+            title: 'Rename',
+            hint: 'the new name under this document\u2019s own owner',
+            input: seeded(record.doc.displayName),
+            submit: (value) => {
+                this.modal = undefined;
+                this.apply(moveDoc(record, value));
+            },
+        };
+    }
+    /** Delivery limits belong to the profile, per owner — not to the document. */
+    explainLimit() {
+        this.notice = { text: 'Delivery limits are per owner on the profile; set one with `crtr profile project limit`.', ok: false };
+        this.tui.requestRender();
+    }
+    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.onCancel?.();
+            return;
+        }
+        this.onSubmit?.({ edited: [...this.edited] });
+    }
+    // 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, railRow) {
+        if (this.busy !== undefined)
+            return theme.fg('warning', this.busy);
+        if (this.modal?.kind === 'choice')
+            return theme.fg('dim', '↑↓/jk 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.searching)
+            return theme.fg('dim', 'type to search names · enter keep · esc clear');
+        if (this.notice === undefined && this.plans.error !== undefined) {
+            return theme.fg('warning', truncateToWidth(`dry run refused: ${this.plans.error}`, width));
+        }
+        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 === 'rail'
+            ? `${move} row · ${railGesture(railRow)}`
+            : this.zone === 'docs'
+                ? `${move} row · ${this.docsGesture()} · / search · y id`
+                : this.detail.editing
+                    ? `${move} field · enter edit · e add · x remove · w preview · b body · u unlisted · m limit · r rename · y id · esc read`
+                    : this.detail.bodyOpen
+                        ? `${move} scroll · ctrl-d/u page · g/G ends · y id · esc collapse`
+                        : `${move} scroll · enter body · e edit · y id · esc list`;
+        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));
+    }
+    /** What the focused row does when opened. A directory expands; a document
+     *  opens its dossier. */
+    docsGesture() {
+        return this.docs.onGroup ? 'space/enter open' : 'enter dossier';
+    }
+    render(width) {
+        const height = this.terminalRows();
+        const bodyHeight = Math.max(1, height - PAGE_CHROME_ROWS);
+        const railVisible = width >= RAIL_MIN_TOTAL_WIDTH;
+        const rows = this.railRows();
+        this.railIndex = Math.max(0, Math.min(this.railIndex, rows.length - 1));
+        const rail = (railWidth) => renderRail({
+            rows,
+            index: this.railIndex,
+            width: railWidth,
+            height: bodyHeight,
+            focused: this.zone === 'rail',
+            matched: this.docs.visibleCount,
+            total: this.rows.length,
+        });
+        let body;
+        if (width >= THREE_COLUMN_MIN_WIDTH) {
+            const docsWidth = docsWidthFor(width);
+            const detailWidth = Math.max(1, width - RAIL_WIDTH - docsWidth - DIVIDER_WIDTH);
+            const middle = columns(this.docs.render(docsWidth, bodyHeight, this.zone === 'docs'), docsWidth, this.modal === undefined
+                ? this.detail.render(detailWidth, bodyHeight, this.zone === 'detail')
+                : this.renderModal(detailWidth, bodyHeight), detailWidth);
+            body = columns(rail(RAIL_WIDTH), 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');
+            body = columns(rail(RAIL_WIDTH), RAIL_WIDTH, panel, panelWidth);
+        }
+        else if (this.modal !== undefined) {
+            body = this.renderModal(width, bodyHeight);
+        }
+        else if (this.zone === 'rail') {
+            body = rail(width);
+        }
+        else if (this.zone === 'detail') {
+            body = this.detail.render(width, bodyHeight, true);
+        }
+        else {
+            body = this.docs.render(width, bodyHeight, true);
+        }
+        const pending = PLANNED_EVENTS.filter((event) => this.plans.peek(event) === undefined).length;
+        const delivered = this.plans.peek(this.snapshot.event)?.docs.filter((record) => record.finalRung !== 'none').length;
+        const meta = [
+            this.snapshot.event,
+            delivered === undefined ? '' : `${delivered} delivered`,
+            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, rows[this.railIndex]),
+        });
+    }
+}
+/** What the focused rail row does, which differs by row: an event dials, a
+ *  typed row opens its field, and an enum cycles in place with enter left free
+ *  to move zones. */
+function railGesture(row) {
+    switch (railEnter(row)) {
+        case 'dial':
+            return 'space/enter dial · l documents';
+        case 'edit':
+            return 'space/enter edit · l documents';
+        default:
+            return 'space change · enter documents';
+    }
+}
+/** 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, profiles) {
+    return runTuiPage(({ tui, terminal, bindings, suspendForChild }, control) => {
+        const shell = new ContextAdminShell(seed, tui, () => terminal.rows, bindings, suspendForChild, profiles);
+        shell.onCancel = control.cancel;
+        shell.onSubmit = control.submit;
+        return shell;
+    });
+}