@north-light/crouter 0.3.294 → 0.3.296

package/dist/clients/attach/render/crtr-output.js

@@ -251,42 +251,72 @@ function surfaceEntryText(entry, theme) {
         constraints.push(`gate ${predicateValueText(entry.gate)}`);
     return `${theme.fg('text', constraints.join(' '))} ${theme.fg('dim', 'at')} ${theme.fg(rungTone(entry.at), entry.at)}`;
 }
-function labelledFact(label, value, theme) {
-    return `${theme.fg('dim', label)} ${value}`;
-}
-/** The routing block under the folded call's header line: scope and gate
- *  together, then the surface entries, then the routing line. A fact the
- *  invocation does not state is left out rather than shown as empty. */
-function memoryRoutingLines(routing, theme) {
-    const indent = '  ';
-    const lines = [];
-    const placement = [];
+const ROUTING_INDENT = '  ';
+/** The routing block under the folded call's header line: one line per field,
+ *  in the order the substrate resolves them. A fact the invocation does not
+ *  state is left out rather than shown as empty. */
+function memoryRoutingFields(routing, theme) {
+    const label = (text) => theme.fg('dim', text);
+    const fields = [];
     if (routing.scope !== undefined)
-        placement.push(labelledFact('scope', theme.fg('text', routing.scope), theme));
+        fields.push({ label: label('scope'), values: [theme.fg('text', routing.scope)] });
     if (routing.gate !== undefined)
-        placement.push(labelledFact('gate', theme.fg('text', routing.gate), theme));
-    if (placement.length > 0)
-        lines.push(`${indent}${placement.join(theme.fg('dim', ' · '))}`);
-    const surfaces = routing.surfaces.length === 0
-        ? theme.fg('muted', 'none')
-        : routing.surfaces.map((entry) => surfaceEntryText(entry, theme)).join(theme.fg('dim', ', '));
-    lines.push(`${indent}${labelledFact('surface', surfaces, theme)}`);
+        fields.push({ label: label('gate'), values: [theme.fg('text', routing.gate)] });
+    fields.push({
+        label: label('surface'),
+        values: routing.surfaces.length === 0
+            ? [theme.fg('muted', 'none')]
+            : routing.surfaces.map((entry) => surfaceEntryText(entry, theme)),
+    });
     if (routing.whenAndWhyToRead !== undefined) {
-        lines.push(`${indent}${labelledFact('when-and-why-to-read', theme.fg('text', routing.whenAndWhyToRead), theme)}`);
+        fields.push({ label: label('when-and-why-to-read'), values: [theme.fg('text', routing.whenAndWhyToRead)] });
+    }
+    return fields;
+}
+/** One field's rows: the label, then its values in a column of their own. Each
+ *  value starts at that column — so a second surface entry reads as a sibling of
+ *  the first — and a value too long for the pane wraps under it. A field that
+ *  states SEVERAL values wraps one notch deeper still, which is what keeps a
+ *  wrapped surface entry from reading as the next entry. */
+function routingFieldLines(field, width) {
+    const head = `${ROUTING_INDENT}${field.label} `;
+    const column = visibleWidth(head);
+    const valueIndent = ' '.repeat(column);
+    const wrapIndent = field.values.length > 1 ? `${valueIndent}  ` : valueIndent;
+    const lines = [];
+    for (const value of field.values) {
+        const wrapped = wrapTextWithAnsi(value, Math.max(1, width - visibleWidth(wrapIndent)));
+        wrapped.forEach((line, index) => {
+            const prefix = index > 0 ? wrapIndent : lines.length === 0 ? head : valueIndent;
+            lines.push(`${prefix}${line}`);
+        });
     }
     return lines;
 }
-/** A folded call that states more than one line. Every line is clipped to the
- *  pane, never wrapped: the viewer's frame length depends on a folded call
- *  painting exactly the rows it reports. */
+/** A folded memory call: its header line, then its routing fields. Values WRAP
+ *  rather than clip — the row states the document's whole reach, so a value cut
+ *  off at the pane edge is routing the human cannot read. Wrapping keeps the
+ *  folded call painting exactly the rows it reports, because the viewer
+ *  measures a block by rendering it at the width it paints at and caches that
+ *  measurement per width (MeasuredContainer). What must hold at every width is
+ *  that no row overhangs the pane, or the terminal wraps a row nobody counted. */
 class FoldedCrtrCallComponent {
-    lines;
-    constructor(lines) {
-        this.lines = lines;
+    header;
+    fields;
+    constructor(header, fields) {
+        this.header = header;
+        this.fields = fields;
     }
     invalidate() { }
     render(width) {
-        return this.lines.map((line) => truncateToWidth(line, width, '…'));
+        const lines = wrapTextWithAnsi(this.header, Math.max(1, width));
+        for (const field of this.fields)
+            lines.push(...routingFieldLines(field, width));
+        // Final backstop: a pane too narrow to leave the value column any room to
+        // wrap into (24 cells for when-and-why-to-read, 12 for a wrapped surface
+        // entry) is the only way a row can overhang. It erases the value it clips
+        // rather than trimming it — at that width the label alone fills the pane.
+        return lines.map((line) => truncateToWidth(line, width, ''));
     }
 }
 /** Syntax-color flags and their values while leaving the command path and
@@ -860,7 +890,7 @@ export function createCrtrBashToolDefinition(args, fold = new FoldedToolCallCont
             if (routing !== undefined) {
                 const named = routing.name === '' ? '' : ` ${theme.fg('toolTitle', theme.bold(routing.name))}`;
                 const header = `${styledPrefix} ${theme.fg('toolTitle', theme.bold(routing.leaf))}${named}`;
-                return fold.capture(new FoldedCrtrCallComponent([header, ...memoryRoutingLines(routing, theme)]));
+                return fold.capture(new FoldedCrtrCallComponent(header, memoryRoutingFields(routing, theme)));
             }
             const styledPath = path
                 ? ` ${fold.folded ? styleFoldedCrtrTokens(pathTokens, theme) : theme.fg('toolTitle', theme.bold(path))}`