@north-light/crouter 0.3.169 → 0.3.171

package/dist/clients/attach/render/context-message.js

@@ -1,7 +1,7 @@
 // render/context-message.ts — the terminal viewer's foldable renderer for
-// crouter-generated context. Session bearings, situational updates, fresh-revive
-// kickoffs, context-size nudges, and node inbox digests retain their full model-visible body and
-// runtime role, while this display-only component presents them consistently:
+// crouter-generated context. Session bearings, situational updates, lifecycle
+// steering, recovery prompts, and inbox digests retain their full model-visible
+// body and runtime role, while this display-only component presents them consistently:
 // collapsed → one dim line; expanded (Ctrl+O) → the ordinary user-message
 // surface, regardless of the message's runtime role. It implements
 // `setExpanded`, so the global tool-display cycle folds these blocks alongside

package/dist/clients/attach/render/diagram.js

@@ -11,14 +11,14 @@
 //     byte-identical to `--color off`). So the rendered lines are safe to splice
 //     back into markdown inside a plain ``` code fence — pi's Markdown then shows
 //     them verbatim in monospace, no escape-code leakage, no re-wrapping.
-//   • `renderMarkdown` (humanloop — the sole org-wide termrender caller) is
+//   • `renderMarkdown` (crouter's sole org-wide termrender binding) is
 //     synchronous and memoized, so this is a plain string→string transform with
 //     no async swap or component lifecycle.
 //
 // Scope: Mermaid and a single-line `text`/`plain`/untagged Unicode-arrow chain.
 // The wider termrender directive vocabulary remains out of scope — see the base
 // prompt's Diagrams note.
-import { ensureRenderer, isRendererReady, renderMarkdown } from '@crouton-kit/humanloop';
+import { ensureRenderer, isRendererReady, renderMarkdown } from '../../../core/termrender/termrender.js';
 /** A complete Mermaid fence, including normal Markdown's optional three-space
  *  indentation. Line-anchored (m flag), non-greedy body (captured). An unclosed
  *  fence (still streaming) does not match, so mid-stream text is left raw and

package/dist/clients/attach/render/measured-container.d.ts

@@ -0,0 +1,94 @@
+import { Container, type Component } from '@earendil-works/pi-tui';
+/** The block at the viewport's top row, plus the line offset within it. */
+export interface ScrollAnchor {
+    block: Component;
+    offset: number;
+}
+/** A measurable, sliceable ordered block list. The viewport never touches
+ * components directly — it addresses blocks by flat index, and holds scroll
+ * position as a block identity. */
+export interface ViewportSource {
+    /** Visible blocks, in visual order. */
+    blockCount(): number;
+    /** Rendered line count of block `i` at `width` (renders + caches on miss). */
+    blockHeight(i: number, width: number): number;
+    /** Cached rendered lines of block `i` at `width`. */
+    blockLines(i: number, width: number): readonly string[];
+    /** Total rendered lines at `width`. */
+    totalHeight(width: number): number;
+    /** Absolute content line at which block `i` starts. */
+    blockStart(i: number, width: number): number;
+    /** The block component at flat index `i`. */
+    blockAt(i: number): Component | undefined;
+    /** The anchor for the block containing absolute line `line`. */
+    anchorAt(line: number, width: number): ScrollAnchor | undefined;
+    /** Absolute top line for `anchor` against current measurements, or undefined
+     * when the block is gone entirely. */
+    anchorLine(anchor: ScrollAnchor, width: number): number | undefined;
+    /** Clear cached measurements after a component-level invalidation. */
+    invalidate(): void;
+    /** Monotonic; bumped by every structural or content mutation. */
+    revision(): number;
+}
+/**
+ * A container whose direct children are independently rendered and measured.
+ *
+ * `children` is public on pi-tui's Container, but it must never be mutated from
+ * outside these methods: this class owns the visible-index, height, and prefix
+ * invariants that make identity anchors safe across transcript mutations.
+ */
+export declare class MeasuredContainer extends Container implements ViewportSource {
+    private readonly childCache;
+    /** Direct children hidden by a collapsed tool-group summary. Never wrap a
+     * child: the cache and pi callback paths both key on this exact identity. */
+    readonly hiddenChildren: Set<Component>;
+    /** Rendered line counts for visible children at `measureWidth`. */
+    private heights;
+    /** `prefix[i]` is the start line of visible child `i`. */
+    private prefix;
+    /** The first visible-child index whose prefix onward must be rebuilt. */
+    private prefixValidTo;
+    private visibleChildren;
+    private measureWidth;
+    private mutationRevision;
+    addChild(component: Component): void;
+    setHidden(component: Component, hidden: boolean): void;
+    markDirty(component?: Component): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    invalidate(): void;
+    render(width: number): string[];
+    blockCount(): number;
+    blockHeight(index: number, width: number): number;
+    blockLines(index: number, width: number): readonly string[];
+    totalHeight(width: number): number;
+    blockStart(index: number, width: number): number;
+    blockAt(index: number): Component | undefined;
+    anchorAt(line: number, width: number): ScrollAnchor | undefined;
+    anchorLine(anchor: ScrollAnchor, width: number): number | undefined;
+    revision(): number;
+    private visible;
+    private visibleIndexOf;
+    private ensureWidth;
+    private dropMeasurements;
+    private linesFor;
+    /** Rebuild the prefix ending at `endExclusive`; `prefixValidTo` is the first
+     * child whose height/prefix may be stale, so `prefix[prefixValidTo]` is valid. */
+    private rebuildPrefixThrough;
+}
+/** Concatenates measured containers into the transcript's one flat block space. */
+export declare class CompositeViewportSource implements ViewportSource {
+    private readonly parts;
+    constructor(parts: readonly MeasuredContainer[]);
+    blockCount(): number;
+    blockHeight(index: number, width: number): number;
+    blockLines(index: number, width: number): readonly string[];
+    totalHeight(width: number): number;
+    blockStart(index: number, width: number): number;
+    blockAt(index: number): Component | undefined;
+    anchorAt(line: number, width: number): ScrollAnchor | undefined;
+    anchorLine(anchor: ScrollAnchor, width: number): number | undefined;
+    invalidate(): void;
+    revision(): number;
+    private locate;
+}

package/dist/clients/attach/render/measured-container.js

@@ -0,0 +1,307 @@
+import { Container } from '@earendil-works/pi-tui';
+/**
+ * A container whose direct children are independently rendered and measured.
+ *
+ * `children` is public on pi-tui's Container, but it must never be mutated from
+ * outside these methods: this class owns the visible-index, height, and prefix
+ * invariants that make identity anchors safe across transcript mutations.
+ */
+export class MeasuredContainer extends Container {
+    childCache = new Map();
+    /** Direct children hidden by a collapsed tool-group summary. Never wrap a
+     * child: the cache and pi callback paths both key on this exact identity. */
+    hiddenChildren = new Set();
+    /** Rendered line counts for visible children at `measureWidth`. */
+    heights = [];
+    /** `prefix[i]` is the start line of visible child `i`. */
+    prefix = [0];
+    /** The first visible-child index whose prefix onward must be rebuilt. */
+    prefixValidTo = 0;
+    visibleChildren;
+    measureWidth;
+    mutationRevision = 0;
+    addChild(component) {
+        const visibleCount = this.visible().length;
+        super.addChild(component);
+        this.visibleChildren = undefined;
+        this.heights.push(undefined);
+        this.prefixValidTo = Math.min(this.prefixValidTo, visibleCount);
+        this.mutationRevision++;
+    }
+    setHidden(component, hidden) {
+        const wasHidden = this.hiddenChildren.has(component);
+        const oldVisibleIndex = wasHidden ? undefined : this.visibleIndexOf(component);
+        if (hidden)
+            this.hiddenChildren.add(component);
+        else
+            this.hiddenChildren.delete(component);
+        this.childCache.delete(component);
+        if (!wasHidden && hidden && oldVisibleIndex !== undefined) {
+            this.heights.splice(oldVisibleIndex, 1);
+            this.prefix.length = this.heights.length + 1;
+            this.prefixValidTo = Math.min(this.prefixValidTo, oldVisibleIndex);
+        }
+        else if (wasHidden && !hidden) {
+            this.visibleChildren = undefined;
+            const insertionIndex = this.visibleIndexOf(component);
+            if (insertionIndex !== undefined) {
+                this.heights.splice(insertionIndex, 0, undefined);
+                this.prefixValidTo = Math.min(this.prefixValidTo, insertionIndex);
+            }
+        }
+        else if (oldVisibleIndex !== undefined) {
+            // Preserve RenderCacheContainer's behavior when this is called with the
+            // current state: evict this child and re-measure it on its next render.
+            this.heights[oldVisibleIndex] = undefined;
+            this.prefixValidTo = Math.min(this.prefixValidTo, oldVisibleIndex);
+        }
+        this.visibleChildren = undefined;
+        this.mutationRevision++;
+    }
+    markDirty(component) {
+        if (component) {
+            const visibleIndex = this.visibleIndexOf(component);
+            this.childCache.delete(component);
+            if (visibleIndex !== undefined) {
+                this.heights[visibleIndex] = undefined;
+                this.prefixValidTo = Math.min(this.prefixValidTo, visibleIndex);
+            }
+        }
+        else {
+            this.dropMeasurements();
+        }
+        this.mutationRevision++;
+    }
+    removeChild(component) {
+        const visibleIndex = this.visibleIndexOf(component);
+        super.removeChild(component);
+        this.childCache.delete(component);
+        this.hiddenChildren.delete(component);
+        if (visibleIndex !== undefined) {
+            this.heights.splice(visibleIndex, 1);
+            this.prefix.length = this.heights.length + 1;
+            this.prefixValidTo = Math.min(this.prefixValidTo, visibleIndex);
+        }
+        this.visibleChildren = undefined;
+        this.mutationRevision++;
+    }
+    clear() {
+        super.clear();
+        this.childCache.clear();
+        this.hiddenChildren.clear();
+        this.heights = [];
+        this.prefix = [0];
+        this.prefixValidTo = 0;
+        this.visibleChildren = undefined;
+        this.mutationRevision++;
+    }
+    invalidate() {
+        super.invalidate();
+        this.dropMeasurements();
+        this.mutationRevision++;
+    }
+    render(width) {
+        this.ensureWidth(width);
+        const lines = [];
+        for (let i = 0; i < this.visible().length; i++)
+            lines.push(...this.linesFor(i, width));
+        return lines;
+    }
+    blockCount() {
+        return this.visible().length;
+    }
+    blockHeight(index, width) {
+        this.ensureWidth(width);
+        return this.linesFor(index, width).length;
+    }
+    blockLines(index, width) {
+        this.ensureWidth(width);
+        return this.linesFor(index, width);
+    }
+    totalHeight(width) {
+        this.ensureWidth(width);
+        this.rebuildPrefixThrough(this.visible().length, width);
+        return this.prefix[this.visible().length] ?? 0;
+    }
+    blockStart(index, width) {
+        this.ensureWidth(width);
+        if (index < 0 || index >= this.visible().length)
+            return 0;
+        this.rebuildPrefixThrough(index, width);
+        return this.prefix[index] ?? 0;
+    }
+    blockAt(index) {
+        return this.visible()[index];
+    }
+    anchorAt(line, width) {
+        this.ensureWidth(width);
+        const count = this.visible().length;
+        this.rebuildPrefixThrough(count, width);
+        const total = this.prefix[count] ?? 0;
+        if (line < 0 || line >= total)
+            return undefined;
+        let low = 0;
+        let high = count - 1;
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const start = this.prefix[middle] ?? 0;
+            const end = this.prefix[middle + 1] ?? start;
+            if (line < start)
+                high = middle - 1;
+            else if (line >= end)
+                low = middle + 1;
+            else
+                return { block: this.visible()[middle], offset: line - start };
+        }
+        return undefined;
+    }
+    anchorLine(anchor, width) {
+        this.ensureWidth(width);
+        const childIndex = this.children.indexOf(anchor.block);
+        if (childIndex === -1)
+            return undefined;
+        const visibleIndex = this.visibleIndexOf(anchor.block);
+        if (visibleIndex !== undefined) {
+            const height = this.blockHeight(visibleIndex, width);
+            if (height === 0)
+                return this.blockStart(visibleIndex, width);
+            return this.blockStart(visibleIndex, width) + Math.min(anchor.offset, height - 1);
+        }
+        // A hidden child resolves to the visible sibling that preceded it, so a fold
+        // leaves the viewport on its summary rather than throwing it to live bottom.
+        for (let i = childIndex - 1; i >= 0; i--) {
+            const preceding = this.children[i];
+            const precedingVisibleIndex = this.visibleIndexOf(preceding);
+            if (precedingVisibleIndex !== undefined)
+                return this.blockStart(precedingVisibleIndex, width);
+        }
+        return 0;
+    }
+    revision() {
+        return this.mutationRevision;
+    }
+    visible() {
+        if (!this.visibleChildren)
+            this.visibleChildren = this.children.filter((child) => !this.hiddenChildren.has(child));
+        return this.visibleChildren;
+    }
+    visibleIndexOf(component) {
+        const index = this.visible().indexOf(component);
+        return index === -1 ? undefined : index;
+    }
+    ensureWidth(width) {
+        if (this.measureWidth === width)
+            return;
+        this.measureWidth = width;
+        this.dropMeasurements();
+    }
+    dropMeasurements() {
+        this.childCache.clear();
+        this.heights = this.visible().map(() => undefined);
+        this.prefix = [0];
+        this.prefixValidTo = 0;
+    }
+    linesFor(index, width) {
+        const child = this.visible()[index];
+        if (!child)
+            return [];
+        let cached = this.childCache.get(child);
+        if (!cached || cached.width !== width) {
+            cached = { width, lines: child.render(width) };
+            this.childCache.set(child, cached);
+        }
+        this.heights[index] = cached.lines.length;
+        return cached.lines;
+    }
+    /** Rebuild the prefix ending at `endExclusive`; `prefixValidTo` is the first
+     * child whose height/prefix may be stale, so `prefix[prefixValidTo]` is valid. */
+    rebuildPrefixThrough(endExclusive, width) {
+        const count = this.visible().length;
+        const end = Math.min(Math.max(endExclusive, 0), count);
+        const start = Math.min(this.prefixValidTo, end);
+        if (this.prefix.length === 0)
+            this.prefix = [0];
+        this.prefix[0] = 0;
+        for (let i = start; i < end; i++) {
+            const height = this.heights[i] ?? this.linesFor(i, width).length;
+            this.prefix[i + 1] = (this.prefix[i] ?? 0) + height;
+        }
+        if (end > this.prefixValidTo)
+            this.prefixValidTo = end;
+    }
+}
+/** Concatenates measured containers into the transcript's one flat block space. */
+export class CompositeViewportSource {
+    parts;
+    constructor(parts) {
+        this.parts = parts;
+    }
+    blockCount() {
+        return this.parts.reduce((count, part) => count + part.blockCount(), 0);
+    }
+    blockHeight(index, width) {
+        const located = this.locate(index);
+        return located ? located.part.blockHeight(located.index, width) : 0;
+    }
+    blockLines(index, width) {
+        const located = this.locate(index);
+        return located ? located.part.blockLines(located.index, width) : [];
+    }
+    totalHeight(width) {
+        return this.parts.reduce((total, part) => total + part.totalHeight(width), 0);
+    }
+    blockStart(index, width) {
+        let offset = 0;
+        for (const part of this.parts) {
+            const count = part.blockCount();
+            if (index < count)
+                return offset + part.blockStart(index, width);
+            index -= count;
+            offset += part.totalHeight(width);
+        }
+        return 0;
+    }
+    blockAt(index) {
+        const located = this.locate(index);
+        return located?.part.blockAt(located.index);
+    }
+    anchorAt(line, width) {
+        if (line < 0)
+            return undefined;
+        for (const part of this.parts) {
+            const height = part.totalHeight(width);
+            if (line < height)
+                return part.anchorAt(line, width);
+            line -= height;
+        }
+        return undefined;
+    }
+    anchorLine(anchor, width) {
+        let offset = 0;
+        for (const part of this.parts) {
+            const line = part.anchorLine(anchor, width);
+            if (line !== undefined)
+                return offset + line;
+            offset += part.totalHeight(width);
+        }
+        return undefined;
+    }
+    invalidate() {
+        for (const part of this.parts)
+            part.invalidate();
+    }
+    revision() {
+        return this.parts.reduce((revision, part) => revision + part.revision(), 0);
+    }
+    locate(index) {
+        if (index < 0)
+            return undefined;
+        for (const part of this.parts) {
+            const count = part.blockCount();
+            if (index < count)
+                return { part, index };
+            index -= count;
+        }
+        return undefined;
+    }
+}

package/dist/clients/attach/render/transcript-copy.d.ts

@@ -0,0 +1,9 @@
+import type { ChatView } from './chat-view.js';
+import type { ViewportSource } from './measured-container.js';
+import type { TranscriptViewport } from './viewport.js';
+export type CopyTarget = 'message' | 'last-assistant' | 'tool' | 'transcript';
+export interface TranscriptCopy {
+    /** Copy `target`; returns the status-region confirmation to show. */
+    copy(target: CopyTarget): string;
+}
+export declare function createTranscriptCopy(chat: ChatView, viewport: TranscriptViewport, source: ViewportSource): TranscriptCopy;

package/dist/clients/attach/render/transcript-copy.js

@@ -0,0 +1,81 @@
+import { writeClipboardTextEverywhere } from '../../../core/clipboard-text.js';
+function hasText(text) {
+    return text !== undefined && text.trim() !== '';
+}
+function lineCount(text) {
+    return text.split('\n').length;
+}
+function copiedTo(system, tmux) {
+    if (system && tmux)
+        return 'clipboard + tmux buffer';
+    if (system)
+        return 'clipboard';
+    if (tmux)
+        return 'tmux buffer';
+    return undefined;
+}
+/** Resolves the newest copyable block wholly visible before falling back to one
+ * merely intersecting the current viewport. */
+function visibleMessageText(chat, viewport, source) {
+    const { first, last, lastFullyVisible } = viewport.visibleBlocks();
+    const textAt = (index) => {
+        const block = source.blockAt(index);
+        return block ? chat.blockText(block) : undefined;
+    };
+    for (let index = Math.min(last, lastFullyVisible); index >= first; index--) {
+        const text = textAt(index);
+        if (hasText(text))
+            return text;
+    }
+    for (let index = last; index >= first; index--) {
+        const text = textAt(index);
+        if (hasText(text))
+            return text;
+    }
+    return undefined;
+}
+export function createTranscriptCopy(chat, viewport, source) {
+    return {
+        copy(target) {
+            let resolved;
+            let emptyNotice;
+            switch (target) {
+                case 'message': {
+                    const text = visibleMessageText(chat, viewport, source);
+                    if (hasText(text))
+                        resolved = { text, label: 'message' };
+                    emptyNotice = 'Nothing to copy — no visible message';
+                    break;
+                }
+                case 'last-assistant': {
+                    const text = chat.getLastAssistantText();
+                    if (hasText(text))
+                        resolved = { text, label: 'last assistant message' };
+                    emptyNotice = 'Nothing to copy — no assistant message yet';
+                    break;
+                }
+                case 'tool': {
+                    const text = chat.getLastToolOutputText();
+                    if (hasText(text))
+                        resolved = { text, label: 'tool output' };
+                    emptyNotice = 'Nothing to copy — no tool output yet';
+                    break;
+                }
+                case 'transcript': {
+                    const text = chat.getTranscriptPlainText();
+                    if (hasText(text))
+                        resolved = { text, label: 'transcript' };
+                    emptyNotice = 'Nothing to copy — transcript is empty';
+                    break;
+                }
+            }
+            if (!resolved)
+                return emptyNotice;
+            const { system, tmux } = writeClipboardTextEverywhere(resolved.text);
+            const destination = copiedTo(system, tmux);
+            if (!destination)
+                return 'Copy failed — no clipboard tool found';
+            return `Copied ${resolved.label} (${lineCount(resolved.text)} lines) — ${destination}`;
+        },
+    };
+}

package/dist/clients/attach/render/viewport.d.ts

@@ -0,0 +1,29 @@
+import type { ViewportSource } from './measured-container.js';
+/** The flat block range occupied by the most recently rendered viewport. */
+type VisibleBlocks = {
+    first: number;
+    last: number;
+    lastFullyVisible: number;
+};
+/**
+ * A virtualized, identity-anchored transcript viewport. It owns only scroll
+ * state; all measurement and line caching remain with its ViewportSource.
+ */
+export interface TranscriptViewport {
+    /** Exactly `rows` lines, bottom-aligned and top-padded with empty rows. */
+    renderSlice(width: number, rows: number): string[];
+    /** Scroll by `lines` (negative = toward older content). */
+    scrollBy(lines: number): boolean;
+    /** Scroll by one page in `direction`. */
+    scrollPage(direction: 'up' | 'down'): boolean;
+    /** Pin back to the live bottom. */
+    goLive(): void;
+    /** True while the viewport is pinned to the bottom. */
+    isLive(): boolean;
+    /** Flat blocks intersecting the visible slice and its last whole block. */
+    visibleBlocks(): VisibleBlocks;
+    /** Forward frame invalidation without exposing the source to the frame. */
+    invalidate(): void;
+}
+export declare function createTranscriptViewport(source: ViewportSource): TranscriptViewport;
+export {};