@north-light/crouter 0.3.170 → 0.3.172

package/dist/clients/attach/render/html-markdown.js

@@ -0,0 +1,228 @@
+// Supported raw HTML for assistant Markdown in the attach viewer.
+//
+// This is deliberately a semantic allowlist, not an HTML renderer. Complete
+// details/summary blocks become terminal disclosure rows, while kbd and mark
+// become theme-styled inline text. Everything else stays literal, and Markdown
+// code spans/fences are protected before the allowlist scanner runs.
+const PROTECTED_PREFIX = '\u0000\u0001CRTR_HTML_CODE_';
+const PROTECTED_SUFFIX = '\u0002';
+const DETAILS_OPEN = /<details\b[^>]*>/gi;
+const DETAILS_TAG = /<\/?details\b[^>]*>/gi;
+const VALID_DETAILS_OPEN = /^<details(?:[ \t\r\n]+open)?[ \t\r\n]*>$/i;
+const VALID_DETAILS_CLOSE = /^<\/details[ \t\r\n]*>$/i;
+const SUMMARY_OPEN = /^[ \t\r\n]*<summary[ \t\r\n]*>/i;
+const SUMMARY_CLOSE = /<\/summary[ \t\r\n]*>/i;
+const INLINE_HTML = /<(kbd|mark)>([^<>\n]*?)<\/\1[ \t]*>/gi;
+const SUPPORTED_HTML = /<(?:details|kbd|mark)\b/i;
+function protectedToken(index) {
+    return `${PROTECTED_PREFIX}${index}${PROTECTED_SUFFIX}`;
+}
+function lineWithoutEnding(line) {
+    return line.endsWith('\n') ? line.slice(0, -1).replace(/\r$/, '') : line;
+}
+function protectFencedCode(source, protectedParts) {
+    const lines = source.match(/[^\n]*(?:\n|$)/g)?.filter((line) => line !== '') ?? [];
+    const out = [];
+    for (let index = 0; index < lines.length;) {
+        const openingLine = lineWithoutEnding(lines[index]);
+        const opening = /^ {0,3}(`{3,}|~{3,})[^\n]*$/.exec(openingLine);
+        if (!opening) {
+            out.push(lines[index]);
+            index++;
+            continue;
+        }
+        const marker = opening[1];
+        const markerChar = marker[0];
+        let end = index + 1;
+        for (; end < lines.length; end++) {
+            const candidate = lineWithoutEnding(lines[end]);
+            const closing = /^ {0,3}(`+|~+)[ \t]*$/.exec(candidate)?.[1];
+            if (closing?.[0] === markerChar && closing.length >= marker.length) {
+                end++;
+                break;
+            }
+        }
+        const raw = lines.slice(index, end).join('');
+        const tokenIndex = protectedParts.push(raw) - 1;
+        out.push(protectedToken(tokenIndex));
+        index = end;
+    }
+    return out.join('');
+}
+function protectInlineCode(source, protectedParts) {
+    let out = '';
+    let index = 0;
+    while (index < source.length) {
+        if (source[index] !== '`') {
+            out += source[index];
+            index++;
+            continue;
+        }
+        let openingEnd = index + 1;
+        while (source[openingEnd] === '`')
+            openingEnd++;
+        const markerLength = openingEnd - index;
+        let cursor = openingEnd;
+        let closingEnd = -1;
+        while (cursor < source.length) {
+            const next = source.indexOf('`', cursor);
+            if (next === -1)
+                break;
+            let runEnd = next + 1;
+            while (source[runEnd] === '`')
+                runEnd++;
+            if (runEnd - next === markerLength) {
+                closingEnd = runEnd;
+                break;
+            }
+            cursor = runEnd;
+        }
+        if (closingEnd === -1) {
+            out += source.slice(index, openingEnd);
+            index = openingEnd;
+            continue;
+        }
+        const tokenIndex = protectedParts.push(source.slice(index, closingEnd)) - 1;
+        out += protectedToken(tokenIndex);
+        index = closingEnd;
+    }
+    return out;
+}
+function protectMarkdownCode(source) {
+    const protectedParts = [];
+    const fenced = protectFencedCode(source, protectedParts);
+    const masked = protectInlineCode(fenced, protectedParts);
+    return {
+        masked,
+        restore: (text) => text.replace(/\u0000\u0001CRTR_HTML_CODE_(\d+)\u0002/g, (_whole, rawIndex) => protectedParts[Number(rawIndex)] ?? ''),
+    };
+}
+function isEscaped(source, index) {
+    let slashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === '\\'; cursor--)
+        slashes++;
+    return slashes % 2 === 1;
+}
+/** HTML phrasing content for this allowlist is plain text. Escape CommonMark's
+ * ASCII punctuation so a key label such as `[x]` cannot become a link, while
+ * the Markdown renderer removes the escapes from the displayed text. */
+function escapeMarkdownInline(text) {
+    return [...text].map((char) => /[!-/:-@[-`{-~]/.test(char) ? `\\${char}` : char).join('');
+}
+function transformInlineHtml(text, styles) {
+    return text.replace(INLINE_HTML, (whole, rawTag, rawBody, offset) => {
+        if (isEscaped(text, offset))
+            return whole;
+        const tag = rawTag.toLowerCase();
+        const body = tag === 'kbd' ? rawBody.replace(/\s+/g, ' ').trim() : rawBody.trim();
+        if (body === '')
+            return whole;
+        const escaped = escapeMarkdownInline(body);
+        return tag === 'kbd' ? styles.kbd(escaped) : styles.mark(escaped);
+    });
+}
+function findDetailsRange(source, openEnd) {
+    DETAILS_TAG.lastIndex = openEnd;
+    let depth = 1;
+    let nested = false;
+    for (let match = DETAILS_TAG.exec(source); match; match = DETAILS_TAG.exec(source)) {
+        if (isEscaped(source, match.index))
+            continue;
+        const closing = /^<\//.test(match[0]);
+        if (closing) {
+            depth--;
+            if (depth === 0)
+                return { closeStart: match.index, closeTag: match[0], end: DETAILS_TAG.lastIndex, nested };
+        }
+        else {
+            depth++;
+            nested = true;
+        }
+    }
+    DETAILS_TAG.lastIndex = 0;
+    return undefined;
+}
+function renderDetails(source, openTag, openEnd, range, options) {
+    if (!VALID_DETAILS_OPEN.test(openTag) || !VALID_DETAILS_CLOSE.test(range.closeTag) || range.nested)
+        return undefined;
+    const inner = source.slice(openEnd, range.closeStart);
+    const summaryOpen = SUMMARY_OPEN.exec(inner);
+    if (!summaryOpen)
+        return undefined;
+    const afterSummaryOpen = summaryOpen[0].length;
+    const summaryClose = SUMMARY_CLOSE.exec(inner.slice(afterSummaryOpen));
+    if (!summaryClose)
+        return undefined;
+    const summaryEnd = afterSummaryOpen + summaryClose.index;
+    const summary = inner.slice(afterSummaryOpen, summaryEnd).trim();
+    if (summary === '')
+        return undefined;
+    const summaryRendered = transformInlineHtml(summary, options.styles);
+    const openByAttribute = /[ \t\r\n]open[ \t\r\n]*>$/i.test(openTag);
+    const expanded = options.detailsExpanded ?? openByAttribute;
+    const glyph = expanded ? '▾' : '▸';
+    if (!expanded)
+        return `${glyph} ${summaryRendered} ${options.styles.hint('— ctrl+o to expand')}`;
+    const bodyStart = summaryEnd + summaryClose[0].length;
+    const body = inner.slice(bodyStart).trim();
+    if (body === '')
+        return `${glyph} ${summaryRendered}`;
+    return `${glyph} ${summaryRendered}\n\n${transformInlineHtml(body, options.styles)}`;
+}
+/** Transform the strict supported HTML subset in one Markdown string. */
+export function transformHtmlMarkdown(source, options) {
+    if (!SUPPORTED_HTML.test(source))
+        return source;
+    const protectedMarkdown = protectMarkdownCode(source);
+    const masked = protectedMarkdown.masked;
+    let out = '';
+    let cursor = 0;
+    DETAILS_OPEN.lastIndex = 0;
+    for (let match = DETAILS_OPEN.exec(masked); match; match = DETAILS_OPEN.exec(masked)) {
+        if (match.index < cursor)
+            continue;
+        const range = findDetailsRange(masked, DETAILS_OPEN.lastIndex);
+        if (!range) {
+            out += transformInlineHtml(masked.slice(cursor, match.index), options.styles);
+            out += masked.slice(match.index);
+            cursor = masked.length;
+            break;
+        }
+        out += transformInlineHtml(masked.slice(cursor, match.index), options.styles);
+        const whole = masked.slice(match.index, range.end);
+        if (isEscaped(masked, match.index)) {
+            out += whole;
+        }
+        else {
+            const rendered = renderDetails(masked, match[0], DETAILS_OPEN.lastIndex, range, options);
+            out += rendered ?? whole;
+        }
+        cursor = range.end;
+        DETAILS_OPEN.lastIndex = range.end;
+    }
+    if (cursor < masked.length)
+        out += transformInlineHtml(masked.slice(cursor), options.styles);
+    return protectedMarkdown.restore(out);
+}
+/** Copy an assistant message for terminal rendering, enhancing only text parts. */
+export function transformMessageHtml(message, options) {
+    const content = message.content;
+    if (typeof content === 'string') {
+        const transformed = transformHtmlMarkdown(content, options);
+        return transformed === content ? message : { ...message, content: transformed };
+    }
+    if (!Array.isArray(content))
+        return message;
+    let changed = false;
+    const next = content.map((part) => {
+        const candidate = part;
+        if (candidate?.type !== 'text' || typeof candidate.text !== 'string')
+            return part;
+        const transformed = transformHtmlMarkdown(candidate.text, options);
+        if (transformed === candidate.text)
+            return part;
+        changed = true;
+        return { ...candidate, text: transformed };
+    });
+    return changed ? { ...message, content: next } : message;
+}

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

@@ -0,0 +1,96 @@
+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;
+    private rawLinesFor;
+    private invalidateHeight;
+    /** 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,322 @@
+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.invalidateHeight(oldVisibleIndex);
+        }
+        else if (wasHidden && !hidden) {
+            this.visibleChildren = undefined;
+            const insertionIndex = this.visibleIndexOf(component);
+            if (insertionIndex !== undefined) {
+                this.heights.splice(insertionIndex, 0, undefined);
+                this.invalidateHeight(insertionIndex);
+                this.invalidateHeight(insertionIndex + 1);
+            }
+        }
+        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.invalidateHeight(oldVisibleIndex);
+            this.invalidateHeight(oldVisibleIndex + 1);
+        }
+        this.visibleChildren = undefined;
+        this.mutationRevision++;
+    }
+    markDirty(component) {
+        if (component) {
+            const visibleIndex = this.visibleIndexOf(component);
+            this.childCache.delete(component);
+            if (visibleIndex !== undefined) {
+                this.invalidateHeight(visibleIndex);
+                this.invalidateHeight(visibleIndex + 1);
+            }
+        }
+        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.invalidateHeight(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 lines = this.rawLinesFor(index, width);
+        const previous = this.rawLinesFor(index - 1, width);
+        // Transcript blocks own their own one-row outer breathing room. Like CSS
+        // margins, adjacent blank boundaries collapse instead of summing to two.
+        const rendered = previous.at(-1) === '' && lines[0] === '' ? lines.slice(1) : lines;
+        this.heights[index] = rendered.length;
+        return rendered;
+    }
+    rawLinesFor(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);
+        }
+        return cached.lines;
+    }
+    invalidateHeight(index) {
+        if (index < 0)
+            return;
+        if (index < this.heights.length)
+            this.heights[index] = undefined;
+        this.prefix.length = this.heights.length + 1;
+        this.prefixValidTo = Math.min(this.prefixValidTo, Math.min(index, this.heights.length));
+    }
+    /** 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/scroll-animation.d.ts

@@ -0,0 +1,8 @@
+import type { TranscriptViewport } from './viewport.js';
+export interface ScrollAnimator {
+    /** Animate one scroll step in `direction`, coalescing with a burst in flight. */
+    page(direction: 'up' | 'down'): void;
+    /** Stop mid-flight — other scroll input took over, or the session ended. */
+    cancel(): void;
+}
+export declare function createScrollAnimator(viewport: TranscriptViewport, requestRender: () => void): ScrollAnimator;