@north-light/crouter 0.3.243 → 0.3.245

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

@@ -0,0 +1,31 @@
+import { type Rung, type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+import type { NodeConfigSubject } from '../../../../core/substrate/subject-fields.js';
+/** The profile project entry whose `memory` rung ceilings this document's
+ *  store, or null when no project governs it. */
+export interface CapOwner {
+    path: string;
+    memory: Rung;
+}
+/** 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, DeliveryRecord>;
+    capOwner: CapOwner | null;
+    readOnly: boolean;
+    /** 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: DeliveryRecord, 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: DeliveryRecord, 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: DeliveryRecord, context: DossierContext, width: number): string[];
+export declare function bodyLineCount(body: string): number;

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

@@ -0,0 +1,189 @@
+// The dossier's read face: one memory 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 { SURFACE_EVENTS, rungRank } from '../../../../core/substrate/schema.js';
+import { allMismatches, CLAUSE_SEPARATOR, explainRecordGate, formatClause, } from '../../../../core/substrate/gate-explain.js';
+import { formatCost, plural, rungCostsOf } 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);
+    if (record.doc.shortForm.trim() !== '') {
+        out.push('');
+        out.push(...indent(wrapped(record.doc.shortForm, inner)));
+    }
+    out.push(...renderDossierDelivery(record, context, width));
+    const lines = bodyLineCount(record.doc.body);
+    if (bodyOpen) {
+        out.push('');
+        out.push(...indent(new Markdown(record.doc.body, 0, 0, getMarkdownTheme()).render(inner)));
+    }
+    else if (lines === 0) {
+        out.push('', ...dim('no body — this document is its routing line', width));
+    }
+    else {
+        out.push('', ...dim(`enter  read the body \u2014 ${plural(lines, 'line', 'lines')}`, 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}READ WHEN`));
+    const routing = record.doc.whenAndWhyToRead.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.kind} \u00b7 ${record.scope}${record.nodeLocal ? ' \u00b7 node-local' : ''}${context.readOnly ? ` ${READ_ONLY_GLYPH}` : ''}`;
+    const names = wrapped(record.name, 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 costs = rungCostsOf(record);
+    const delivers = record.finalRung !== 'none';
+    const ceilingLowered = rungRank(record.cappedRung) < rungRank(record.authoredRung);
+    const rung = delivers ? record.finalRung : 'nothing';
+    const cost = delivers ? ` \u00b7 ${formatCost(costs[record.finalRung]) || '~0'} of ${formatCost(costs.content) || '~0'}` : '';
+    const color = !delivers ? 'dim' : ceilingLowered ? 'warning' : 'success';
+    const asked = `${context.event} \u2192 `;
+    const answer = `${rung}${cost}`;
+    const out = [''];
+    if (visibleWidth(asked) + visibleWidth(answer) <= inner) {
+        out.push(`${INDENT}${theme.fg('dim', asked)}${theme.fg(color, rung)}${theme.fg('dim', cost)}`);
+    }
+    else {
+        // Too narrow for one row: the event names itself and its verdict wraps
+        // beneath, rather than the cost ellipsizing off the end.
+        out.push(...indent(wrapped(asked, inner)).map((line) => theme.fg('dim', line)));
+        out.push(...indent(wrapped(answer, inner)).map((line) => theme.fg(color, line)));
+    }
+    const warn = (text) => {
+        out.push(...indent(wrapped(text, inner)).map((line) => theme.fg('warning', line)));
+    };
+    let unexplained = false;
+    const gateBlock = (side, noun) => {
+        const outcome = side === 'doc' ? record.docGate : record.entryGate;
+        if (outcome === null || outcome.pass)
+            return [];
+        const clauses = explainRecordGate(record, side, context.subject);
+        if (clauses.length === 0) {
+            unexplained = true;
+            warn(`${noun} fails: ${outcome.reason}`);
+            return clauses;
+        }
+        // A gate carrying a defect can never match ANY node, so it names a
+        // different remedy than a node that merely does not qualify.
+        warn(allMismatches(clauses) ? `${noun} fails` : `${noun} never matches`);
+        for (const clause of clauses) {
+            out.push(...clauseRows(formatClause(clause), inner).map((line) => theme.fg('warning', line)));
+        }
+        return clauses;
+    };
+    const failing = [...gateBlock('doc', 'gate'), ...gateBlock('entry', 'entry gate')];
+    if (!unexplained && allMismatches(failing)) {
+        out.push(...dim('dial the snapshot at left to load it here', width));
+    }
+    if (record.matchedEntry === null && record.authoredEntries.length > 0) {
+        out.push(...indent(wrapped(`${plural(record.authoredEntries.length, 'entry', 'entries')} for this event, none matched`, inner)).map((line) => theme.fg('dim', line)));
+    }
+    if (ceilingLowered) {
+        warn(context.capOwner === null
+            ? `capped to ${record.cappedRung} by a profile ceiling on this store`
+            : `capped to ${record.cappedRung} by the ${context.capOwner.memory} ceiling on ${context.capOwner.path}`);
+    }
+    if (record.shadowedBy !== null) {
+        out.push(...indent(wrapped(`shadowed by the ${record.shadowedBy.scope} copy at ${record.shadowedBy.path}`, inner)).map((line) => theme.fg('muted', line)));
+    }
+    const also = SURFACE_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;
+}
+export function bodyLineCount(body) {
+    const trimmed = body.replace(/\n+$/, '');
+    return trimmed === '' ? 0 : trimmed.split('\n').length;
+}
+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

@@ -44,6 +44,11 @@ export declare class ContextAdminShell implements Component, Focusable {
     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;
@@ -54,8 +59,13 @@ export declare class ContextAdminShell implements Component, Focusable {
      *  drawn against, so it earns the page-level gesture. */
     private cyclesEvent;
     handleInput(data: string): void;
-    /** The rail's rows are the snapshot axes followed by the filter facets, so
-     *  one cursor and one gesture drive both sections. */
+    /** 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 handleRail;
     private handleDocs;
     private openSearch;
@@ -63,6 +73,18 @@ export declare class ContextAdminShell implements Component, Focusable {
      *  modal over the rows it is selecting. */
     private handleSearch;
     private handleDetail;
+    /** The resting face: reading, and the two gestures that leave it. */
+    private handleRead;
+    /** 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
+     *  profile ceiling is not one of them; it lives in the profile manifest. */
+    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;
@@ -90,8 +112,8 @@ export declare class ContextAdminShell implements Component, Focusable {
     private handleModal;
     private renderModal;
     private footer;
-    /** What the focused row does when opened. A directory answers to space, a
-     *  document to enter, and a directory that is also a document to both. */
+    /** What the focused row does when opened. A directory expands; a document
+     *  opens its dossier. */
     private docsGesture;
     render(width: number): string[];
     /** What the delivering documents spend on this event. An estimate, and a