@north-light/api 0.3.580 → 0.3.588

package/dist/commands/sys/context/admin/rail-panel.js

@@ -0,0 +1,229 @@
+// The rail: three sections in one row grammar. EVENTS names every activity a
+// rule can fire on and how many documents each one delivers, and dials which of
+// them the page is planning. SNAPSHOT holds the configuration axes that plan
+// is computed against — changing one re-plans every event. FILTERS holds the
+// question asked of the plan — changing one only changes what is shown. An enum
+// cycles in place; a free-text row opens a field.
+import { resolve as resolvePath } from 'node:path';
+import { truncateToWidth } from '@earendil-works/pi-tui';
+import { padAnsi, theme } from '../../../../core/tui/panel.js';
+import { tildify } from '../../../../core/fs-utils.js';
+import { KINDS, RUNGS } from '../../../../core/substrate/schema.js';
+import { PLANNED_EVENTS } from '../resolve.js';
+import { payloadAxisFor } from './model.js';
+import { OWNER_TYPES } from './list-view.js';
+const RUNG_FACETS = ['any', ...RUNGS.filter((rung) => rung !== 'none'), 'silent'];
+const ORIGIN_FACETS = ['any', ...OWNER_TYPES];
+const KIND_FACETS = ['any', ...KINDS];
+const STATE_FACETS = ['any', 'delivering', 'gated', 'shadowed', 'no-rule'];
+/** The FILTERS rows for one filter value. `doc kind` is spelled out because the
+ *  snapshot above it dials the NODE's kind. */
+export function facetsOf(filters) {
+    return [
+        { id: 'rung', label: 'rung', value: filters.rung, typed: false },
+        { id: 'origin', label: 'owner', value: filters.origin, typed: false },
+        { id: 'kind', label: 'doc kind', value: filters.kind, typed: false },
+        { id: 'state', label: 'state', value: filters.state, typed: false },
+        { id: 'query', label: 'search', value: filters.query === '' ? 'any' : filters.query, typed: true },
+    ];
+}
+export function cycleFacet(filters, id, delta) {
+    const step = (values, current) => {
+        const at = values.indexOf(current);
+        return values[(Math.max(0, at) + delta + values.length) % values.length];
+    };
+    switch (id) {
+        case 'rung':
+            return { ...filters, rung: step(RUNG_FACETS, filters.rung) };
+        case 'origin':
+            return { ...filters, origin: step(ORIGIN_FACETS, filters.origin) };
+        case 'kind':
+            return { ...filters, kind: step(KIND_FACETS, filters.kind) };
+        case 'state':
+            return { ...filters, state: step(STATE_FACETS, filters.state) };
+        case 'query':
+            return filters;
+    }
+}
+/** The configuration rows for a snapshot. The event and its payload are not
+ *  here — they belong to the EVENTS section, where the payload sits under the
+ *  count it explains. */
+export function axesOf(snapshot, profileName) {
+    return [
+        { id: 'kind', label: 'kind', value: snapshot.kind, typed: true },
+        { id: 'mode', label: 'mode', value: snapshot.mode, typed: false },
+        { id: 'lifecycle', label: 'lifecycle', value: snapshot.lifecycle, typed: false },
+        { id: 'manager', label: 'manager', value: snapshot.hasManager ? 'yes' : 'no', typed: false },
+        { id: 'depth', label: 'depth', value: String(snapshot.depth), typed: false },
+        { id: 'profile', label: 'profile', value: profileName, typed: false },
+        { id: 'cwd', label: 'cwd', value: tildify(snapshot.cwd), typed: true },
+    ];
+}
+/** The payload field for the dialled event, or nothing when the event reads no
+ *  payload — on boot there is nothing it could change. It renders inside the
+ *  EVENTS section, directly under the count it explains. */
+export function payloadRowOf(snapshot) {
+    const payload = payloadAxisFor(snapshot.event);
+    if (payload === null)
+        return undefined;
+    const value = payload === 'file' ? snapshot.file : payload === 'docName' ? snapshot.docName : snapshot.command;
+    return {
+        id: 'payload',
+        label: payload === 'file' ? 'file' : payload === 'docName' ? 'doc' : 'command',
+        value: value === '' ? '(none — nothing matches)' : value,
+        typed: true,
+    };
+}
+/** Cycle one enum axis, returning the changed snapshot. A typed axis is never
+ *  cycled — the shell opens a field for it instead. */
+export function cycleAxis(snapshot, id, delta, profiles = []) {
+    const step = (values, current) => {
+        const at = values.indexOf(current);
+        return values[(Math.max(0, at) + delta + values.length) % values.length];
+    };
+    switch (id) {
+        case 'event':
+            return { ...snapshot, event: step(PLANNED_EVENTS, snapshot.event) };
+        case 'mode': {
+            const mode = step(['base', 'orchestrator'], snapshot.mode);
+            // Lifecycle follows mode the way node creation defaults it, so cycling to
+            // orchestrator does not leave a resident-only persona reading as terminal.
+            return { ...snapshot, mode, lifecycle: mode === 'orchestrator' ? 'resident' : 'terminal' };
+        }
+        case 'lifecycle':
+            return { ...snapshot, lifecycle: step(['terminal', 'resident'], snapshot.lifecycle) };
+        case 'manager':
+            return { ...snapshot, hasManager: !snapshot.hasManager };
+        case 'depth':
+            return { ...snapshot, depth: Math.max(0, snapshot.depth + delta) };
+        case 'profile': {
+            const ids = [null, ...profiles.map((entry) => entry.id)];
+            return { ...snapshot, profileId: step(ids, snapshot.profileId) };
+        }
+        default:
+            return snapshot;
+    }
+}
+/** Apply a typed axis's submitted value. */
+export function setTypedAxis(snapshot, id, value) {
+    const trimmed = value.trim();
+    if (id === 'kind')
+        return trimmed === '' ? snapshot : { ...snapshot, kind: trimmed };
+    if (id === 'cwd')
+        return trimmed === '' ? snapshot : { ...snapshot, cwd: resolvePath(trimmed) };
+    if (id !== 'payload')
+        return snapshot;
+    const axis = payloadAxisFor(snapshot.event);
+    if (axis === 'file')
+        return { ...snapshot, file: trimmed };
+    if (axis === 'docName')
+        return { ...snapshot, docName: trimmed };
+    if (axis === 'command')
+        return { ...snapshot, command: trimmed };
+    return snapshot;
+}
+/** The value a typed axis's field is seeded with. */
+export function typedAxisValue(snapshot, id) {
+    if (id === 'kind')
+        return snapshot.kind;
+    if (id === 'cwd')
+        return snapshot.cwd;
+    const axis = payloadAxisFor(snapshot.event);
+    return axis === 'file' ? snapshot.file : axis === 'docName' ? snapshot.docName : axis === 'command' ? snapshot.command : '';
+}
+const LABEL_WIDTH = 10;
+/** A rail row's identity, which the shell holds the cursor by. The list's
+ *  composition changes whenever the dialled event moves the payload row, so an
+ *  offset kept across that change points at a different row. */
+export function railRowKey(row) {
+    if (row.kind === 'event')
+        return `event:${row.event.event}`;
+    return row.kind === 'axis' ? `axis:${row.axis.id}` : `facet:${row.facet.id}`;
+}
+/** What enter does on a rail row: an event dials it, a typed row opens its
+ *  field, and every other row hands the keyboard to the documents. Space does
+ *  the same thing on the first two and cycles the value on the last. */
+export function railEnter(row) {
+    if (row === undefined)
+        return 'documents';
+    if (row.kind === 'event')
+        return 'dial';
+    if (row.kind === 'axis')
+        return row.axis.typed ? 'edit' : 'documents';
+    return row.facet.typed ? 'edit' : 'documents';
+}
+export function railRowsOf(events, payload, axes, facets) {
+    const rows = [];
+    for (const event of events) {
+        rows.push({ kind: 'event', event });
+        if (event.dialled && payload !== undefined)
+            rows.push({ kind: 'axis', axis: payload, indent: true });
+    }
+    for (const axis of axes)
+        rows.push({ kind: 'axis', axis, indent: false });
+    for (const facet of facets)
+        rows.push({ kind: 'facet', facet });
+    return rows;
+}
+/** All three sections as one column. `index` runs over `rows`, while the
+ *  section headings and the blank rows between them are drawn but never
+ *  selectable. */
+export function renderRail(opts) {
+    const { rows, index, width, height, focused, matched, total } = opts;
+    const lines = [];
+    let cursorLine = 0;
+    /** `plain` is the uncoloured body without its leading space — what the accent
+     *  mark recolours, so no inner reset cuts the highlight short. */
+    const push = (at, marked, body, dim, plain) => {
+        if (at === index)
+            cursorLine = lines.length;
+        if (at === index && focused)
+            lines.push(theme.bg('selectedBg', padAnsi(body, width)));
+        else if (at === index || marked) {
+            lines.push(`${theme.fg('accent', '▌')}${padAnsi(theme.fg('accent', plain), width - 1)}`);
+        }
+        else
+            lines.push(padAnsi(dim, width));
+    };
+    const labelled = (at, label, value, indent) => {
+        const labelRoom = Math.max(1, LABEL_WIDTH - indent);
+        const room = Math.max(1, width - LABEL_WIDTH - 2);
+        const padded = `${' '.repeat(indent)}${padAnsi(truncateToWidth(label, labelRoom), labelRoom)}`;
+        const shown = truncateToWidth(value, room);
+        push(at, false, ` ${padded} ${shown}`, ` ${theme.fg('dim', padded)} ${shown}`, `${padded} ${shown}`);
+    };
+    const evented = (at, row) => {
+        const count = row.delivers === undefined ? '…' : String(row.delivers);
+        const tone = row.delivers === undefined || row.delivers === 0 ? 'dim' : 'success';
+        const room = Math.max(1, width - 2 - count.length);
+        const name = padAnsi(truncateToWidth(row.event, room), room);
+        const toned = theme.fg(tone, count);
+        // The dialled event wears the same mark a selected row wears, because it IS
+        // the selection every other pane is drawn against.
+        push(at, row.dialled, ` ${name} ${toned}`, ` ${theme.fg('dim', name)} ${toned}`, `${name} ${count}`);
+    };
+    const sectionOf = (row) => row.kind === 'facet' ? 'filters' : row.kind === 'event' || row.indent ? 'events' : 'snapshot';
+    const headings = { events: ' EVENTS', snapshot: ' SNAPSHOT', filters: ` FILTERS · ${matched} of ${total}` };
+    let section;
+    rows.forEach((row, at) => {
+        const belongs = sectionOf(row);
+        if (belongs !== section) {
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(theme.fg('dim', headings[belongs]), '');
+            section = belongs;
+        }
+        if (row.kind === 'event')
+            evented(at, row.event);
+        else if (row.kind === 'axis')
+            labelled(at, row.axis.label, row.axis.value, row.indent ? 2 : 0);
+        else
+            labelled(at, row.facet.label, row.facet.value, 0);
+    });
+    const maxStart = Math.max(0, lines.length - height);
+    const start = Math.min(Math.max(0, cursorLine - Math.floor(height / 2)), maxStart);
+    const out = lines.slice(start, start + height);
+    while (out.length < height)
+        out.push('');
+    return out;
+}

package/dist/commands/sys/context/admin/read-view.d.ts

@@ -0,0 +1,27 @@
+import { type PlannedEvent } from '../resolve.js';
+import type { NodeConfigSubject } from '../../../../core/substrate/subject-fields.js';
+import { type AdminRecord } from './model.js';
+type SurfaceEvent = PlannedEvent;
+/** What the read face needs beyond the record: the event it is judged against,
+ *  the sibling events' records, and the two facts the shell resolves. */
+export interface DossierContext {
+    event: SurfaceEvent;
+    records: Map<SurfaceEvent, AdminRecord>;
+    readOnly: boolean;
+    /** The body, once the reader opened it — the plan carries none. */
+    body: string | undefined;
+    /** The configuration every record here was planned against — what a failed
+     *  gate is explained against. Null when there is no node config at all. */
+    subject: NodeConfigSubject | null;
+}
+/** The resting card, and — when `bodyOpen` — the document's own text beneath
+ *  it in place of the affordance line that names it. */
+export declare function renderDossierRead(record: AdminRecord, context: DossierContext, width: number, bodyOpen: boolean): string[];
+/** Identity and routing — what the edit face keeps overhead of its field list,
+ *  because they are the context a field is being edited against. */
+export declare function renderDossierHeader(record: AdminRecord, context: DossierContext, width: number): string[];
+/** Does it load here, what does it cost, and — only when there is one — what
+ *  interfered. The three questions the old verdict, cost table and event grid
+ *  each answered a piece of. */
+export declare function renderDossierDelivery(record: AdminRecord, context: DossierContext, width: number): string[];
+export {};

package/dist/commands/sys/context/admin/read-view.js

@@ -0,0 +1,172 @@
+// The dossier's read face: one document as the thing a person reads to decide
+// whether it should load into this context.
+//
+// Pure rendering. It returns styled lines already wrapped to `width` and never
+// truncates a value — the panel scrolls, so scrolling is the only thing that
+// hides text, and "the routing line never ellipsizes" is structural rather than
+// a rule someone has to remember.
+//
+// One rule decides what appears: a line renders only when it changes what the
+// reader would conclude. A gate that is unset, a cap that lowers nothing, an
+// event that delivers nothing — all absent.
+import { getMarkdownTheme } from '@earendil-works/pi-coding-agent';
+import { Markdown, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { theme, wrapText } from '../../../../core/tui/panel.js';
+import { rungRank } from '../../../../core/substrate/schema.js';
+import { PLANNED_EVENTS } from '../resolve.js';
+import { CLAUSE_SEPARATOR, explainGate, formatClause } from '../../../../core/substrate/gate-explain.js';
+import { ownerTypeOf } from './list-view.js';
+import { plural } from './model.js';
+/** Read-only, at rest: no word and no sentence. The refusal itself is a notice
+ *  fired at the moment a write is attempted. */
+const READ_ONLY_GLYPH = '\u2298';
+/** Every column but the left margin, which every line of the card carries. */
+const INDENT = ' ';
+/** The resting card, and — when `bodyOpen` — the document's own text beneath
+ *  it in place of the affordance line that names it. */
+export function renderDossierRead(record, context, width, bodyOpen) {
+    const inner = Math.max(1, width - INDENT.length);
+    const out = renderDossierHeader(record, context, width);
+    out.push(...renderDossierDelivery(record, context, width));
+    const body = context.body;
+    if (bodyOpen && body !== undefined) {
+        out.push('');
+        out.push(...indent(new Markdown(body, 0, 0, getMarkdownTheme()).render(inner)));
+    }
+    else if (bodyOpen) {
+        out.push('', ...dim('reading the body\u2026', width));
+    }
+    else {
+        out.push('', ...dim('enter  read the body', width));
+    }
+    return out;
+}
+/** A dim line of the card, kept exactly as written while the row can hold it
+ *  and wrapped when it cannot — so a narrow dossier costs a second row rather
+ *  than an ellipsis. */
+function dim(text, width) {
+    const inner = Math.max(1, width - INDENT.length);
+    return visibleWidth(text) <= inner
+        ? [`${INDENT}${theme.fg('dim', text)}`]
+        : indent(wrapped(text, inner)).map((line) => theme.fg('dim', line));
+}
+/** Identity and routing — what the edit face keeps overhead of its field list,
+ *  because they are the context a field is being edited against. */
+export function renderDossierHeader(record, context, width) {
+    const inner = Math.max(1, width - INDENT.length);
+    const out = identityLines(record, context, inner);
+    out.push('', theme.fg('dim', `${INDENT}PREVIEW`));
+    const routing = record.doc.preview.trim();
+    out.push(...(routing === ''
+        ? [theme.fg('dim', `${INDENT}Not declared.`)]
+        : indent(wrapped(routing, inner))));
+    return out;
+}
+/** The name, with the metadata cluster pushed to the far right of the same row
+ *  whenever both fit. A name too long to share the row keeps every character
+ *  and the cluster drops to its own row. */
+function identityLines(record, context, inner) {
+    const meta = `${record.doc.kind} \u00b7 ${ownerTypeOf(record)} ${record.doc.ownerHandle}${record.doc.unlisted ? ' \u00b7 unlisted' : ''}${context.readOnly ? ` ${READ_ONLY_GLYPH}` : ''}`;
+    const names = wrapped(record.doc.displayName, inner);
+    const out = names.map((line) => `${INDENT}${theme.fg('accent', theme.bold(line))}`);
+    const last = names[names.length - 1] ?? '';
+    const gap = inner - visibleWidth(last) - visibleWidth(meta);
+    if (gap >= 2) {
+        out[out.length - 1] = `${INDENT}${theme.fg('accent', theme.bold(last))}${' '.repeat(gap)}${theme.fg('dim', meta)}`;
+        return out;
+    }
+    // The cluster takes its own row, right-aligned under the name — or its own
+    // rows, when the dossier is too narrow to hold it in one.
+    out.push(...wrapped(meta, inner).map((line) => `${INDENT}${' '.repeat(Math.max(0, inner - visibleWidth(line)))}${theme.fg('dim', line)}`));
+    return out;
+}
+/** Does it load here, what does it cost, and — only when there is one — what
+ *  interfered. The three questions the old verdict, cost table and event grid
+ *  each answered a piece of. */
+export function renderDossierDelivery(record, context, width) {
+    const inner = Math.max(1, width - INDENT.length);
+    const delivers = record.finalRung !== 'none';
+    const limitLowered = rungRank(record.cappedRung) < rungRank(record.authoredRung);
+    const rung = delivers ? record.finalRung : 'nothing';
+    const color = !delivers ? 'dim' : limitLowered ? 'warning' : 'success';
+    const asked = `${context.event} \u2192 `;
+    const out = [''];
+    if (visibleWidth(asked) + visibleWidth(rung) <= inner) {
+        out.push(`${INDENT}${theme.fg('dim', asked)}${theme.fg(color, rung)}`);
+    }
+    else {
+        out.push(...indent(wrapped(asked, inner)).map((line) => theme.fg('dim', line)));
+        out.push(...indent(wrapped(rung, inner)).map((line) => theme.fg(color, line)));
+    }
+    const warn = (text) => {
+        out.push(...indent(wrapped(text, inner)).map((line) => theme.fg('warning', line)));
+    };
+    const gate = record.ruleGate;
+    if (record.matchedRule === null && gate !== null && !gate.pass) {
+        const failing = record.authoredRules.find((decision) => !decision.gate.pass)?.rule.if;
+        const clauses = failing === undefined || context.subject === null ? [] : explainGate(failing, context.subject);
+        if (clauses.length === 0) {
+            warn(`rule if fails: ${gate.reason}`);
+        }
+        else {
+            // A defective `if` can never match ANY node, so it names a different
+            // remedy than a node that merely does not qualify.
+            const mismatchOnly = clauses.every((clause) => clause.failure === 'mismatch');
+            warn(mismatchOnly ? 'rule if fails' : 'rule if never matches');
+            for (const clause of clauses) {
+                out.push(...clauseRows(formatClause(clause), inner).map((line) => theme.fg('warning', line)));
+            }
+            if (mismatchOnly)
+                out.push(...dim('dial the snapshot at left to load it here', width));
+        }
+    }
+    else if (record.matchedRule === null && record.authoredRules.length > 0) {
+        out.push(...indent(wrapped(`${plural(record.authoredRules.length, 'rule', 'rules')} for this activity, none matched`, inner)).map((line) => theme.fg('dim', line)));
+    }
+    if (limitLowered) {
+        warn(`limited to ${record.cappedRung} by the profile\u2019s delivery limit for ${record.doc.ownerHandle} (authored ${record.authoredRung})`);
+    }
+    if (record.shadowedBy !== null) {
+        out.push(...indent(wrapped(`shadowed by ${record.shadowedBy.ownerHandle}/${record.shadowedBy.name}`, inner)).map((line) => theme.fg('muted', line)));
+    }
+    const also = PLANNED_EVENTS.filter((event) => event !== context.event)
+        .map((event) => ({ event, held: context.records.get(event) }))
+        .filter((pair) => pair.held !== undefined && pair.held.finalRung !== 'none')
+        .map((pair) => `${pair.event} \u2192 ${pair.held.finalRung}`);
+    if (also.length > 0) {
+        out.push(...indent(wrapped(`also ${also.join(' \u00b7 ')}`, inner)).map((line) => theme.fg('dim', line)));
+    }
+    return out;
+}
+function indent(lines) {
+    return lines.map((line) => `${INDENT}${line}`);
+}
+/** Every column a clause line under a gate header carries. */
+const CLAUSE_INDENT = `${INDENT}  `;
+/** One clause, kept on one row while the pane can hold it. Too wide, it breaks
+ *  at the grammar's own separator — the reader's value on one row, the gate's demand beneath it —
+ *  and each half wraps rather than losing a character to an ellipsis. */
+function clauseRows(clause, inner) {
+    const room = Math.max(1, inner - 2);
+    if (visibleWidth(clause) <= room)
+        return [`${CLAUSE_INDENT}${clause}`];
+    const at = clause.indexOf(CLAUSE_SEPARATOR);
+    if (at === -1)
+        return wrapped(clause, room).map((line) => `${CLAUSE_INDENT}${line}`);
+    return [
+        ...wrapped(clause.slice(0, at), room).map((line) => `${CLAUSE_INDENT}${line}`),
+        ...wrapped(clause.slice(at + 1), Math.max(1, room - 2)).map((line) => `${CLAUSE_INDENT}  ${line}`),
+    ];
+}
+/** `wrapText` is the page's prose wrapper, and its word-oriented contract
+ *  deliberately leaves a filesystem path or a compact JSON predicate intact.
+ *  Values carrying such a token go through pi-tui's character-safe wrapper
+ *  instead, so an over-wide token breaks rather than becoming an ellipsis. */
+function wrapped(text, width) {
+    const clean = text.trim();
+    if (clean === '')
+        return [];
+    return clean.split(/\s+/).some((word) => visibleWidth(word) > width)
+        ? wrapTextWithAnsi(clean, width)
+        : wrapText(clean, width);
+}

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

@@ -0,0 +1,125 @@
+import { type Component, type Focusable, type TUI } from '@earendil-works/pi-tui';
+import { type BindingId, type BindingResolution } from '../../../../core/keybindings/index.js';
+import { type ProfileChoice, type Snapshot } from './model.js';
+export interface AdminResult {
+    edited: string[];
+}
+export declare class ContextAdminShell implements Component, Focusable {
+    private readonly tui;
+    private readonly terminalRows;
+    private readonly bindings;
+    private readonly suspendForChild;
+    private readonly profiles;
+    private snapshot;
+    private plans;
+    private zone;
+    private railIndex;
+    private filters;
+    private rows;
+    /** The search field owns the keyboard while it is open. */
+    private searching;
+    private readonly docs;
+    private readonly detail;
+    private modal;
+    private notice;
+    private busy;
+    private readonly edited;
+    /** Bodies the reader opened, by object id — the plan carries none. */
+    private readonly bodies;
+    private _focused;
+    onCancel?: () => void;
+    onSubmit?: (result: AdminResult) => void;
+    constructor(seed: Snapshot, tui: TUI, terminalRows: () => number, bindings: BindingResolution<BindingId>, suspendForChild: () => () => void, profiles: readonly ProfileChoice[]);
+    set focused(value: boolean);
+    get focused(): boolean;
+    /** 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(): void;
+    dispose(): void;
+    /** Recompute the focused event's plan, refresh the panels from it, and let
+     *  the remaining events fill in behind it. */
+    private rebuild;
+    private refreshRows;
+    /** 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. */
+    private setFilters;
+    private syncDetail;
+    private setSnapshot;
+    /** 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. */
+    private holdRail;
+    private matches;
+    private label;
+    private isDown;
+    private isUp;
+    private isDescend;
+    private isAscend;
+    /** Tab steps the focused event from any zone — the one axis every panel is
+     *  drawn against, so it earns the page-level gesture. */
+    private cyclesEvent;
+    handleInput(data: string): void;
+    /** 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. */
+    private eventRows;
+    /** The rail's rows: the events, then the snapshot axes, then the filter
+     *  facets, so one cursor and one gesture drive all three sections. */
+    private railRows;
+    private profileName;
+    private handleRail;
+    private handleDocs;
+    private openSearch;
+    /** Typing filters live, so the field is the list's own heading rather than a
+     *  modal over the rows it is selecting. */
+    private handleSearch;
+    private handleDetail;
+    /** 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. */
+    private yankId;
+    /** The resting face: reading, and the two gestures that leave it. */
+    private handleRead;
+    /** Open the body in place, fetching it the first time it is opened. */
+    private openBody;
+    /** 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. */
+    private handleEdit;
+    /** 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. */
+    private writeGesture;
+    /** The refusal a read-only document owes the write just attempted, carried by
+     *  the same footer channel every other write outcome uses. */
+    private refusesWrite;
+    /** 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. */
+    private activate;
+    private get record();
+    private apply;
+    private cycleRuleLevel;
+    private removeRule;
+    /** Activity, then match, then level — the three fields a valid rule needs,
+     *  asked in the order the rule reads them. */
+    private composeRule;
+    private flipUnlisted;
+    private editPreview;
+    /** 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. */
+    private editBody;
+    private editMove;
+    /** Delivery limits belong to the profile, per owner — not to the document. */
+    private explainLimit;
+    private openAxisField;
+    private close;
+    private handleModal;
+    private renderModal;
+    private footer;
+    /** What the focused row does when opened. A directory expands; a document
+     *  opens its dossier. */
+    private docsGesture;
+    render(width: number): string[];
+}
+export declare function runContextAdmin(seed: Snapshot, profiles: readonly ProfileChoice[]): Promise<AdminResult | undefined>;