@north-light/crouter 0.3.243 → 0.3.245

package/dist/commands/sys/context/admin/detail-panel.d.ts

@@ -1,6 +1,9 @@
-import { type Rung, type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import type { SurfaceEvent } from '../../../../core/substrate/schema.js';
 import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+import type { NodeConfigSubject } from '../../../../core/substrate/subject-fields.js';
+import { type CapOwner } from './read-view.js';
 import type { DocRow } from './docs-panel.js';
+export type { CapOwner } from './read-view.js';
 /** A field of the focused document the shell can write. `entry` carries an
  *  index into the document's whole surfaces list, not the focused event's
  *  subset, because that list is what a write replaces. */
@@ -26,31 +29,53 @@ export type DetailRow = {
 } | {
     kind: 'move';
 };
-export interface CapOwner {
-    path: string;
-    memory: Rung;
-}
 export declare class ContextDetailPanel {
     private row;
     private event;
     private capOwner;
     private readOnly;
+    private subject;
     private rows;
     private index;
-    /** Lines scrolled past the cursor's own window, so the verdict below the last
-     *  editable row stays reachable. */
-    private tail;
-    setContext(row: DocRow | undefined, event: SurfaceEvent, capOwner: CapOwner | null, readOnly: string | null): void;
+    private face;
+    private open;
+    private scroll;
+    /** Last render's geometry, so a half-pane jump and the end-of-content clamp
+     *  measure against real content rather than a counter nobody can see. */
+    private lastLines;
+    private lastHeight;
+    setContext(row: DocRow | undefined, event: SurfaceEvent, capOwner: CapOwner | null, readOnly: string | null, subject: NodeConfigSubject | null): void;
+    /** True while the field list owns the pane, so the shell routes the write
+     *  letters and teaches them in the footer. */
+    get editing(): boolean;
+    get bodyOpen(): boolean;
     get selected(): DetailRow | undefined;
     /** The entry index a rung cycle or a removal would act on. */
     get selectedEntry(): number | undefined;
+    /** `j`/`k`: a line of the read face, a field of the edit face. */
     move(delta: number): void;
+    /** `ctrl-d`/`ctrl-u`: half a pane, so a long body is crossed in jumps a
+     *  reader can still follow. */
+    page(direction: 1 | -1): void;
+    /** `g`/`G`. */
+    jump(to: 'top' | 'bottom'): void;
+    /** `enter`: the document's own text, in place. False when there is no body,
+     *  so the shell leaves the key alone. */
+    openBody(): boolean;
+    /** `e`: the field list. */
+    edit(): void;
+    /** `esc`/`h`: leave the edit face, else collapse the body. False means the
+     *  read face is already at rest and the shell should leave the dossier. */
+    back(): boolean;
+    private scrollBy;
+    private maxScroll;
+    private record;
+    private context;
     render(width: number, height: number, focused: boolean): string[];
-    private verdict;
-    /** All three rungs, not just the current one, so "what would demoting this
-     *  save" is read rather than computed. */
-    private costs;
-    private acrossEvents;
+    /** Today's field list, under the identity and delivery it is being edited
+     *  against. A row's clarifying tail renders only while that row is focused:
+     *  unfocused, twelve explanations are twelve lines of noise. */
+    private editLines;
 }
 /** The editable rows for one document, in the order the panel draws them. */
 export declare function buildDetailRows(record: DeliveryRecord): DetailRow[];

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

@@ -1,91 +1,194 @@
-// The dossier: one document's editable configuration above the read-only
-// verdict that configuration produces, and below that the document's own
-// opening lines. Every selectable row here is a field the shell can write;
-// everything below the rule is what the planner decided.
+// The dossier: one memory document, read first.
+//
+// Two faces over one pane. The read face is the resting state — who this
+// document is, when an agent reads it, what it says, and whether it loads on
+// this event — and `enter` opens its body in place. The edit face is the field
+// list every write still starts from, one `e` away. The panel owns which face
+// is showing and how far it is scrolled; it owns no text layout.
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { padAnsi, theme, wrapText } from '../../../../core/tui/panel.js';
-import { SURFACE_EVENTS } from '../../../../core/substrate/schema.js';
-import { EVENT_INITIALS, cellStateOf, describeSurfaceEntry, formatCost, plural, rungCostsOf } from './model.js';
-const STATE_WORD = {
-    pending: 'planning…',
-    delivers: 'delivers',
-    capped: 'capped',
-    gated: 'gated out',
-    shadowed: 'shadowed',
-    silent: 'silent',
-};
+import { describeSurfaceEntry, plural } from './model.js';
+import { bodyLineCount, renderDossierDelivery, renderDossierHeader, renderDossierRead, } from './read-view.js';
 export class ContextDetailPanel {
     row;
     event = 'boot';
     capOwner = null;
     readOnly = null;
+    subject = null;
     rows = [];
     index = 0;
-    /** Lines scrolled past the cursor's own window, so the verdict below the last
-     *  editable row stays reachable. */
-    tail = 0;
-    setContext(row, event, capOwner, readOnly) {
+    face = 'read';
+    open = false;
+    scroll = 0;
+    /** Last render's geometry, so a half-pane jump and the end-of-content clamp
+     *  measure against real content rather than a counter nobody can see. */
+    lastLines = 1;
+    lastHeight = 1;
+    setContext(row, event, capOwner, readOnly, subject) {
         const changed = row?.key !== this.row?.key;
         this.row = row;
         this.event = event;
         this.capOwner = capOwner;
         this.readOnly = readOnly;
+        this.subject = subject;
         this.rows = row === undefined ? [] : buildDetailRows(row.anchor);
         if (changed) {
             this.index = 0;
-            this.tail = 0;
+            this.scroll = 0;
+            this.open = false;
+            this.face = 'read';
         }
         this.index = Math.max(0, Math.min(this.index, this.rows.length - 1));
     }
+    /** True while the field list owns the pane, so the shell routes the write
+     *  letters and teaches them in the footer. */
+    get editing() {
+        return this.face === 'edit';
+    }
+    get bodyOpen() {
+        return this.open;
+    }
     get selected() {
-        return this.rows[this.index];
+        return this.face === 'edit' ? this.rows[this.index] : undefined;
     }
     /** The entry index a rung cycle or a removal would act on. */
     get selectedEntry() {
         const row = this.selected;
         return row?.kind === 'entry' ? row.at : undefined;
     }
+    // navigation
+    /** `j`/`k`: a line of the read face, a field of the edit face. */
     move(delta) {
-        const next = this.index + delta;
-        if (next < 0 || next >= this.rows.length) {
-            this.tail = Math.max(0, this.tail + delta);
+        if (this.face === 'edit') {
+            this.index = Math.max(0, Math.min(this.rows.length - 1, this.index + delta));
             return;
         }
-        this.index = next;
-        this.tail = 0;
+        this.scrollBy(delta);
     }
-    render(width, height, focused) {
+    /** `ctrl-d`/`ctrl-u`: half a pane, so a long body is crossed in jumps a
+     *  reader can still follow. */
+    page(direction) {
+        if (this.face === 'edit')
+            return;
+        this.scrollBy(direction * Math.max(1, Math.floor(this.lastHeight / 2)));
+    }
+    /** `g`/`G`. */
+    jump(to) {
+        if (this.face === 'edit')
+            return;
+        this.scroll = to === 'top' ? 0 : this.maxScroll();
+    }
+    /** `enter`: the document's own text, in place. False when there is no body,
+     *  so the shell leaves the key alone. */
+    openBody() {
+        if (this.face === 'edit' || this.row === undefined)
+            return false;
+        if (bodyLineCount(this.record().doc.body) === 0)
+            return false;
+        this.open = true;
+        this.scroll = 0;
+        return true;
+    }
+    /** `e`: the field list. */
+    edit() {
+        if (this.row === undefined)
+            return;
+        this.face = 'edit';
+        this.scroll = 0;
+    }
+    /** `esc`/`h`: leave the edit face, else collapse the body. False means the
+     *  read face is already at rest and the shell should leave the dossier. */
+    back() {
+        if (this.face === 'edit') {
+            this.face = 'read';
+            this.scroll = 0;
+            return true;
+        }
+        if (!this.open)
+            return false;
+        this.open = false;
+        this.scroll = 0;
+        return true;
+    }
+    scrollBy(delta) {
+        this.scroll = Math.max(0, Math.min(this.scroll + delta, this.maxScroll()));
+    }
+    maxScroll() {
+        return Math.max(0, this.lastLines - this.lastHeight);
+    }
+    record() {
         const row = this.row;
-        if (row === undefined) {
+        return row.records.get(this.event) ?? row.anchor;
+    }
+    context() {
+        return {
+            event: this.event,
+            records: this.row?.records ?? new Map(),
+            capOwner: this.capOwner,
+            readOnly: this.readOnly !== null,
+            subject: this.subject,
+        };
+    }
+    // rendering
+    render(width, height, focused) {
+        if (this.row === undefined) {
+            this.lastLines = 1;
+            this.lastHeight = height;
             return fit([theme.fg('dim', ' Select a document.')], height);
         }
-        const record = row.records.get(this.event) ?? row.anchor;
-        const lines = [];
-        const rowLines = new Map();
-        lines.push(truncateToWidth(`${theme.fg('accent', theme.bold(record.name))}${this.readOnly === null ? '' : theme.fg('warning', '  read-only')}`, width));
-        lines.push(truncateToWidth(theme.fg('dim', `${record.kind} · ${record.scope}${record.nodeLocal ? ' · node-local' : ''} · ${record.source.representation}`), width));
-        lines.push(truncateToWidth(theme.fg('dim', record.storePath), width));
-        if (this.readOnly !== null)
-            lines.push(...wrapText(this.readOnly, width).map((line) => theme.fg('warning', line)));
-        lines.push('');
-        const push = (at, body) => {
-            rowLines.set(at, lines.length);
-            lines.push(at === this.index && focused
-                ? theme.bg('selectedBg', padAnsi(truncateToWidth(body, width), width))
-                : at === this.index
-                    ? `${theme.fg('accent', '▌')}${truncateToWidth(body, Math.max(0, width - 1))}`
-                    : ` ${truncateToWidth(body, Math.max(0, width - 1))}`);
+        const record = this.record();
+        const built = this.face === 'read'
+            ? { lines: renderDossierRead(record, this.context(), width, this.open), cursor: undefined }
+            : this.editLines(record, width, focused);
+        const lines = built.lines;
+        // The badge is the pane's last row, so it costs a line of content only
+        // while there is content it cannot show anyway.
+        const overflows = lines.length > height;
+        const viewport = Math.max(1, overflows ? height - 1 : height);
+        this.lastLines = lines.length;
+        this.lastHeight = viewport;
+        let start;
+        if (built.cursor === undefined) {
+            this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, lines.length - viewport)));
+            start = this.scroll;
+        }
+        else {
+            start = Math.min(Math.max(0, built.cursor - Math.floor(viewport / 3)), Math.max(0, lines.length - viewport));
+        }
+        const window = fit(lines.slice(start, start + viewport), viewport);
+        if (!overflows)
+            return window;
+        window.push(badge(start + 1, Math.min(lines.length, start + viewport), lines.length, width));
+        return window;
+    }
+    /** Today's field list, under the identity and delivery it is being edited
+     *  against. A row's clarifying tail renders only while that row is focused:
+     *  unfocused, twelve explanations are twelve lines of noise. */
+    editLines(record, width, focused) {
+        const context = this.context();
+        const lines = [...renderDossierHeader(record, context, width), ...renderDossierDelivery(record, context, width), ''];
+        let cursor = 0;
+        const push = (at, body, tail) => {
+            const own = [body, ...(at === this.index && tail !== undefined ? tailLines(tail, width) : [])];
+            if (at === this.index)
+                cursor = lines.length;
+            for (const line of own) {
+                lines.push(at === this.index && focused
+                    ? theme.bg('selectedBg', padAnsi(truncateToWidth(line, width), width))
+                    : at === this.index
+                        ? `${theme.fg('accent', '\u258c')}${truncateToWidth(line, Math.max(0, width - 1))}`
+                        : ` ${truncateToWidth(line, Math.max(0, width - 1))}`);
+            }
         };
         let at = 0;
         lines.push(theme.fg('dim', ' SURFACES'));
         const surfaces = record.doc.surfaces;
-        if (surfaces.length === 0)
-            push(at++, theme.fg('dim', 'no entries — this document only appears in its listing'));
-        else {
-            for (const entry of surfaces) {
-                const text = describeSurfaceEntry(entry);
-                push(at++, entry.on === this.event ? text : theme.fg('dim', text));
-            }
+        if (surfaces.length === 0) {
+            lines.push(theme.fg('dim', ' no entries — this document only appears in its listing'));
+        }
+        for (const entry of surfaces) {
+            const text = describeSurfaceEntry(entry);
+            push(at++, entry.on === this.event ? text : theme.fg('dim', text));
         }
         push(at++, theme.fg('success', '+ add a surface entry'));
         lines.push('');
@@ -95,71 +198,13 @@ export class ContextDetailPanel {
         push(at++, field('slash', record.doc.slash ? 'yes' : theme.fg('dim', 'no'), width));
         push(at++, field('routing', record.doc.whenAndWhyToRead, width));
         push(at++, field('short form', record.doc.shortForm === '' ? theme.fg('dim', 'none') : record.doc.shortForm, width));
-        push(at++, field('body', theme.fg('dim', `${plural(bodyLines(record.doc.body), 'line', 'lines')} \u2014 opens in $EDITOR`), width));
-        push(at++, field('profile cap', this.capOwner === null
-            ? theme.fg('dim', 'no profile project governs this store — uncapped')
-            : `${this.capOwner.memory}  ${theme.fg('dim', this.capOwner.path)}`, width));
+        push(at++, field('body', theme.fg('dim', plural(bodyLineCount(record.doc.body), 'line', 'lines')), width), 'opens in $EDITOR');
+        push(at++, field('profile cap', this.capOwner === null ? theme.fg('dim', 'uncapped') : `${this.capOwner.memory}  ${theme.fg('dim', this.capOwner.path)}`, width), this.capOwner === null
+            ? 'no profile project governs this store'
+            : 'the highest rung any document from this store can deliver at');
         push(at++, field('canonical name', record.name, width));
-        lines.push('');
-        lines.push(theme.fg('border', '─'.repeat(Math.max(0, width))));
-        lines.push(theme.fg('dim', ` VERDICT · ${this.event}`));
-        lines.push(...this.verdict(record, width));
-        lines.push('');
-        lines.push(theme.fg('dim', ' COST IF DELIVERED · approximate'));
-        lines.push(...this.costs(record, width));
-        lines.push('');
-        lines.push(theme.fg('dim', ' ACROSS EVENTS'));
-        lines.push(...this.acrossEvents(row, width));
-        lines.push('');
-        lines.push(theme.fg('dim', ' BODY'));
-        lines.push(...bodyPreview(record.doc.body, width, height));
-        const cursorLine = rowLines.get(this.index) ?? 0;
-        const maxStart = Math.max(0, lines.length - height);
-        let start = Math.min(Math.max(0, cursorLine - Math.floor(height / 3)), maxStart);
-        if (this.tail > 0)
-            start = Math.min(maxStart, start + this.tail);
-        return fit(lines.slice(start, start + height), height);
-    }
-    verdict(record, width) {
-        const out = [];
-        const cap = record.projectMemoryCap === null ? 'uncapped' : record.projectMemoryCap;
-        out.push(truncateToWidth(`  authored ${theme.bold(record.authoredRung)} → cap ${cap} → ${theme.fg(record.finalRung === 'none' ? 'dim' : 'success', theme.bold(record.finalRung))}`, width));
-        if (!record.docGate.pass)
-            out.push(...wrapText(`  document gate fails: ${record.docGate.reason}`, width).map((line) => theme.fg('warning', line)));
-        if (record.entryGate !== null && !record.entryGate.pass) {
-            out.push(...wrapText(`  entry gate fails: ${record.entryGate.reason}`, width).map((line) => theme.fg('warning', line)));
-        }
-        if (record.matchedEntry === null && record.authoredEntries.length > 0) {
-            out.push(theme.fg('dim', `  ${plural(record.authoredEntries.length, 'entry', 'entries')} for this event, none matched`));
-        }
-        if (record.shadowedBy !== null) {
-            out.push(...wrapText(`  shadowed by the ${record.shadowedBy.scope} copy at ${record.shadowedBy.path}`, width).map((line) => theme.fg('muted', line)));
-        }
-        else if (record.winner) {
-            out.push(theme.fg('dim', '  wins this canonical name'));
-        }
-        return out;
-    }
-    /** All three rungs, not just the current one, so "what would demoting this
-     *  save" is read rather than computed. */
-    costs(record, width) {
-        const costs = rungCostsOf(record);
-        const cells = ['content', 'preview', 'name'].map((rung) => {
-            const text = `${padAnsi(rung, 8)}${padAnsi(formatCost(costs[rung]) || '~0', 8)}`;
-            return rung === record.finalRung ? theme.fg('success', text) : theme.fg('dim', text);
-        });
-        return [truncateToWidth(`  ${cells.join(' ')}`, width)];
-    }
-    acrossEvents(row, width) {
-        return SURFACE_EVENTS.map((event) => {
-            const record = row.records.get(event);
-            const state = record === undefined ? 'silent' : cellStateOf(record);
-            const rung = record === undefined ? 'none' : record.finalRung;
-            const label = padAnsi(`  ${EVENT_INITIALS[event]} ${event}`, 20);
-            const word = STATE_WORD[state] ?? state;
-            const body = `${label} ${padAnsi(word, 11)} ${rung}`;
-            return truncateToWidth(state === 'delivers' || state === 'capped' ? body : theme.fg('dim', body), width);
-        });
+        lines.push(` ${field('store path', theme.fg('dim', record.storePath), Math.max(0, width - 1))}`);
+        return { lines, cursor };
     }
 }
 /** The editable rows for one document, in the order the panel draws them. */
@@ -178,27 +223,22 @@ export function buildDetailRows(record) {
         { kind: 'move' },
     ];
 }
-function bodyLines(body) {
-    const trimmed = body.replace(/\n+$/, '');
-    return trimmed === '' ? 0 : trimmed.split('\n').length;
-}
-/** The document's opening lines, filling the rows the dossier would otherwise
- *  leave blank. Bounded by the pane height: past that the reader is scrolling,
- *  and the body opens in $EDITOR. */
-function bodyPreview(body, width, height) {
-    const trimmed = body.trim();
-    if (trimmed === '')
-        return [theme.fg('dim', '  (empty)')];
-    return trimmed
-        .split('\n')
-        .slice(0, Math.max(1, height))
-        .map((line) => theme.fg('dim', truncateToWidth(`  ${line}`, width)));
-}
 const FIELD_WIDTH = 15;
 function field(label, value, width) {
     const room = Math.max(1, width - FIELD_WIDTH - 2);
     return `${padAnsi(theme.fg('dim', label), FIELD_WIDTH)} ${truncateToWidth(value, room)}`;
 }
+/** A focused row's explanation, hanging under its value rather than its label. */
+function tailLines(text, width) {
+    const room = Math.max(1, width - FIELD_WIDTH - 2);
+    return wrapText(`\u2014 ${text}`, room).map((line) => `${' '.repeat(FIELD_WIDTH + 1)}${theme.fg('dim', line)}`);
+}
+/** Where the visible window sits in the whole document, drawn only while there
+ *  is something outside it. */
+function badge(from, to, total, width) {
+    const text = `${from}\u2013${to} / ${total}`;
+    return theme.fg('dim', `${' '.repeat(Math.max(0, width - text.length))}${text}`);
+}
 function fit(lines, height) {
     const out = [...lines];
     while (out.length < height)

package/dist/commands/sys/context/admin/docs-panel.d.ts

@@ -38,25 +38,22 @@ export declare class ContextDocsPanel {
      *  rollups, which partition the corpus, so a fully collapsed list still
      *  reports its size and a nested rollup is never counted twice. */
     get visibleCount(): number;
-    setRows(rows: DocRow[], event: SurfaceEvent, selectedKey?: string): void;
+    /** Documents that actually load on the dialled event, counted the same way —
+     *  the numerator of the heading's `N of M`. */
+    get loadedCount(): number;
+    setRows(rows: DocRow[], event: SurfaceEvent): void;
     setFilters(filters: Filters): void;
     move(delta: number): void;
     /** True when the focused line can be opened — a directory header. */
     get onGroup(): boolean;
-    /** True when the focused line IS a document rather than merely standing for
-     *  one. A directory that is also a document is both, which is why the two
-     *  gestures split there: space opens it, enter edits it. */
-    get onDocument(): boolean;
     toggleGroup(): void;
-    /** Rebuild the drawn lines, keeping the cursor on the same document (or the
-     *  same directory), and clamping when what it was on is gone. A document that
-     *  owns a directory is drawn as that directory's header, so a held document
-     *  key matches there too. */
+    /** Rebuild the drawn lines, keeping the cursor on whatever it holds — the
+     *  same document, or the same directory header, which a collapsed group draws
+     *  no document row for — and clamping when what it was on is gone. */
     private relayout;
-    render(width: number, height: number, focused: boolean, plans: PlanSet): string[];
-    /** A directory header. Its stats and cost are the whole subtree's; the matrix
-     *  is drawn only when the directory is itself a document, which is what marks
-     *  the one row as both a document and a directory. */
+    render(width: number, height: number, focused: boolean): string[];
+    /** A directory header: a pure rollup of its whole subtree — how many of its
+     *  documents load, and what they cost together. */
     private groupLine;
     private docLine;
     /** Pad rather than trim: this column sets the length of the divider drawn