@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/markdown/markdown-structure.js

@@ -1,10 +1,6 @@
 "use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { isValidElement } from "react";
-/** The `pre` override for a variant's code block: react-markdown renders
- *  fenced code as <pre><code class="language-x">; this reads the code
- *  element's text and language and hands them to the variant instead of
- *  rendering the tree. */
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, isValidElement, useContext, } from "react";
 export function preBlockFor(CodeBlock) {
     return function PreBlock({ children }) {
         const code = _codeElementOf(children);
@@ -14,11 +10,41 @@ export function preBlockFor(CodeBlock) {
         return (_jsx(CodeBlock, { code: _textOf(code.children), language: _languageOf(code) }));
     };
 }
-// Links open beside the conversation, never over it: an embedded widget
-// navigating its host tab loses the thread. noreferrer covers opener
-// isolation for hosts that predate implicit rel=noopener.
+const InsideLinkContext = createContext(false);
 export function TranscriptLink({ href, children, }) {
-    return (_jsx("a", { href: href, target: "_blank", rel: "noreferrer", children: children }));
+    return (_jsx(InsideLinkContext.Provider, { value: true, children: _jsx("a", { href: href, target: "_blank", rel: "noopener noreferrer", children: children }) }));
+}
+const HTTP_URL = /^https?:\/\//i;
+const MAX_FILENAME_LABEL = 60;
+function _filenameOf(src) {
+    if (src === undefined || /^data:/i.test(src)) {
+        return "";
+    }
+    try {
+        const path = new URL(src, "https://placeholder.invalid").pathname;
+        return decodeURIComponent(path.split("/").filter(Boolean).at(-1) ?? "");
+    }
+    catch {
+        return "";
+    }
+}
+function _imageLabelOf(alt, src) {
+    const described = alt?.trim() ?? "";
+    if (described !== "") {
+        return described;
+    }
+    const filename = _filenameOf(src);
+    return filename === ""
+        ? "(no description)"
+        : filename.slice(0, MAX_FILENAME_LABEL);
+}
+export function TranscriptImage({ src, alt, title, }) {
+    const insideLink = useContext(InsideLinkContext);
+    const body = (_jsxs(_Fragment, { children: [_jsx("span", { "data-tf-markdown-image-marker": "", children: "Image:\u00a0" }), _jsx("span", { "data-tf-markdown-image-label": "", children: _imageLabelOf(alt, src) })] }));
+    if (insideLink || src === undefined || !HTTP_URL.test(src)) {
+        return (_jsx("span", { "data-tf-markdown-image": "", title: title, children: body }));
+    }
+    return (_jsx("a", { "data-tf-markdown-image": "", href: src, title: title, target: "_blank", rel: "noopener noreferrer", children: body }));
 }
 function _codeElementOf(children) {
     if (isValidElement(children) && children.type === "code") {
@@ -39,4 +65,3 @@ function _languageOf(code) {
     const match = /language-([\w-]+)/.exec(code.className ?? "");
     return match === null ? null : match[1];
 }
-//# sourceMappingURL=markdown-structure.js.map

package/dist/components/markdown/memoized-blocks.d.ts

@@ -4,4 +4,3 @@ export interface MarkdownBlocksProps {
     components: Partial<Components>;
 }
 export declare function MarkdownBlocks({ children, components }: MarkdownBlocksProps): import("react").JSX.Element;
-//# sourceMappingURL=memoized-blocks.d.ts.map

package/dist/components/markdown/memoized-blocks.js

@@ -5,23 +5,16 @@ import { memo, useId, useMemo } from "react";
 import ReactMarkdown, {} from "react-markdown";
 import remarkBreaks from "remark-breaks";
 import remarkGfm from "remark-gfm";
-// The streaming-markdown memoization spine, shared by both renderer
-// variants (typography lives in styles.css; each variant passes only its
-// structural component map). The lexer splits the document into
-// top-level blocks so a streaming delta re-renders only the block still
-// growing at the tail — every settled block is memoized on its raw text.
-// The pattern is prompt-kit's `markdown` component.
+import { TranscriptImage } from "./markdown-structure.js";
 function parseMarkdownIntoBlocks(markdown) {
     return marked.lexer(markdown).map((token) => token.raw);
 }
 const MemoizedBlock = memo(function MarkdownBlock({ content, components, }) {
     return (_jsx(ReactMarkdown, { remarkPlugins: [remarkGfm, remarkBreaks], components: components, children: content }));
 }, (prev, next) => prev.content === next.content && prev.components === next.components);
-// Callers pass a MODULE-LEVEL components map — a fresh map per render
-// would defeat every block's memo.
 export function MarkdownBlocks({ children, components }) {
     const blockId = useId();
     const blocks = useMemo(() => parseMarkdownIntoBlocks(children), [children]);
-    return (_jsx(_Fragment, { children: blocks.map((block, index) => (_jsx(MemoizedBlock, { content: block, components: components }, `${blockId}-${String(index)}`))) }));
+    const guarded = useMemo(() => ({ ...components, img: TranscriptImage }), [components]);
+    return (_jsx(_Fragment, { children: blocks.map((block, index) => (_jsx(MemoizedBlock, { content: block, components: guarded }, `${blockId}-${String(index)}`))) }));
 }
-//# sourceMappingURL=memoized-blocks.js.map

package/dist/components/markdown/paced-assistant-markdown.d.ts

@@ -2,4 +2,3 @@ export declare function PacedAssistantMarkdown({ text, streaming, }: {
     text: string;
     streaming: boolean;
 }): import("react").JSX.Element;
-//# sourceMappingURL=paced-assistant-markdown.d.ts.map

package/dist/components/markdown/paced-assistant-markdown.js

@@ -1,14 +1,5 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-// The streamed assistant text body, whole: the paced RAW prefix goes
-// through the streaming repair and only then parses, so partial syntax
-// stays the repair layer's job — and a settled row renders its text
-// verbatim. Only text paces; anything else a transcript shows (tool
-// rows, approval cards, receipts) must land the instant it arrives,
-// which is why this component exists at the leaf and not around the row
-// list. While the buffer is non-empty the tail block re-parses per
-// frame instead of per poll; MemoizedBlock confines that to the last
-// block.
 import { usePacedReveal } from "./use-paced-reveal.js";
 import { repairedStreamingMarkdown } from "./streaming-repair.js";
 import { AssistantMarkdown } from "./assistant-markdown.js";
@@ -17,4 +8,3 @@ export function PacedAssistantMarkdown({ text, streaming, }) {
     const settled = !streaming && revealed === text;
     return (_jsx("div", { ref: revealHostRef, className: "tf:min-w-0", children: _jsx(AssistantMarkdown, { children: settled ? text : repairedStreamingMarkdown(revealed) }) }));
 }
-//# sourceMappingURL=paced-assistant-markdown.js.map

package/dist/components/markdown/reveal-pacer.d.ts

@@ -1,20 +1,14 @@
 export declare class RevealPacer {
     private arrived;
-    /** Fractional revealed length at `committedAt`; advances at `ratePerMs`. */
     private position;
     private committedAt;
     private ratePerMs;
     private expectedGapMs;
     private lastArrivalAt;
-    /** False until the first real (non-burst) gap: the mount-burst window,
-     *  where everything reveals instantly. */
     private calibrated;
     private instant;
     constructor(arrivedLength: number, nowMs: number);
     observe(arrivedLength: number, nowMs: number): void;
-    /** The stream is over (finished, cancelled, parked or superseded):
-     *  stop gap-calibrated withholding and sweep the remainder within
-     *  DRAIN_MS. Never decelerates an already-faster reveal. */
     beginDrain(nowMs: number): void;
     revealInstantly(): void;
     revealedLength(nowMs: number): number;
@@ -24,4 +18,3 @@ export declare class RevealPacer {
     private _foldGapIntoExpectation;
     private _commitRevealedAt;
 }
-//# sourceMappingURL=reveal-pacer.d.ts.map

package/dist/components/markdown/reveal-pacer.js

@@ -1,41 +1,18 @@
-// Streamed assistant text arrives in poll-sized lumps (the backend tails
-// persisted rows on a fixed interval), so painting each arrival whole
-// reads as chunky. The pacer buffers arrivals and reveals characters at a
-// rate calibrated to empty the buffer just as the next chunk is expected —
-// the expectation an EWMA over observed inter-arrival gaps, clamped so a
-// long silence cannot teach a crawl nor a burst a flash. Clock-injected
-// and DOM-free so the math is testable with explicit timestamps.
-/** The backend tail-poll interval — the correct prior before evidence. */
 const NOMINAL_GAP_MS = 400;
-/** ~90% converged after ~7 chunks if the cadence shifts; one outlier
- *  moves the estimate at most 30%. */
 const GAP_EWMA_ALPHA = 0.3;
 const MIN_GAP_MS = 120;
 const MAX_GAP_MS = 1500;
-/** Gaps below this are frames of the same poll lump — a mounted replay
- *  delivers its whole backlog this way. Revealed instantly, never taught
- *  to the EWMA, so a replay cannot poison the expectation into a flash. */
 const BURST_GAP_MS = 50;
-/** 80 chars/s: a small buffer finishes early and dry-waits honestly
- *  instead of crawling below reading speed. */
 const MIN_RATE_CHARS_PER_MS = 0.08;
-/** 4000 chars/s: beyond visual distinction from instant, and bounds the
- *  per-frame markdown re-parse churn a huge chunk could cause. */
 const MAX_RATE_CHARS_PER_MS = 4;
-/** Terminal flush is constant-time: a 40-char and a 400-char tail both
- *  finish in 200ms, so short tails don't lurch and long tails don't
- *  typewriter an answer the server already completed. */
 const DRAIN_MS = 200;
 export class RevealPacer {
     arrived;
-    /** Fractional revealed length at `committedAt`; advances at `ratePerMs`. */
     position;
     committedAt;
     ratePerMs = 0;
     expectedGapMs = NOMINAL_GAP_MS;
     lastArrivalAt;
-    /** False until the first real (non-burst) gap: the mount-burst window,
-     *  where everything reveals instantly. */
     calibrated = false;
     instant = false;
     constructor(arrivedLength, nowMs) {
@@ -64,9 +41,6 @@ export class RevealPacer {
         }
         this.ratePerMs = _clamp((this.arrived - this.position) / this.expectedGapMs, MIN_RATE_CHARS_PER_MS, MAX_RATE_CHARS_PER_MS);
     }
-    /** The stream is over (finished, cancelled, parked or superseded):
-     *  stop gap-calibrated withholding and sweep the remainder within
-     *  DRAIN_MS. Never decelerates an already-faster reveal. */
     beginDrain(nowMs) {
         if (this.instant) {
             return;
@@ -109,4 +83,3 @@ export class RevealPacer {
 function _clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
-//# sourceMappingURL=reveal-pacer.js.map

package/dist/components/markdown/shiki-highlighter.d.ts

@@ -1,2 +1 @@
 export declare function highlightWithShiki(code: string, language: string): Promise<string | null>;
-//# sourceMappingURL=shiki-highlighter.d.ts.map

package/dist/components/markdown/shiki-highlighter.js

@@ -1,10 +1,3 @@
-// The lazy chunk behind markdown/highlight.ts — nothing outside that
-// boundary may import this module (the bundle-weight tripwire enforces
-// it). Fine-grained shiki/core with the JavaScript regex engine: no
-// oniguruma wasm, and only the grammar set below — a fenced block in any
-// other language keeps its plain <pre>. This module ships NO CSS (the
-// esbuild-hoists-lazy-CSS trap): tokens carry `--shiki-*` variables that
-// styles.css maps onto the Graphite ink ladder for both modes.
 import { createCssVariablesTheme, createHighlighterCore, } from "shiki/core";
 import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
 const GRAMMARS = [
@@ -21,8 +14,6 @@ const GRAMMARS = [
     import("@shikijs/langs/markdown"),
     import("@shikijs/langs/sql"),
 ];
-// Aliases shiki resolves itself (ts→typescript, sh→shellscript…) ride
-// the grammar registrations; this set is what `loadedLanguages` reports.
 const THEME = createCssVariablesTheme({
     name: "tf-css-variables",
     variablePrefix: "--shiki-",
@@ -46,4 +37,3 @@ export async function highlightWithShiki(code, language) {
     }
     return core.codeToHtml(code, { lang: resolved, theme: "tf-css-variables" });
 }
-//# sourceMappingURL=shiki-highlighter.js.map

package/dist/components/markdown/streaming-repair.d.ts

@@ -1,2 +1 @@
 export declare function repairedStreamingMarkdown(text: string): string;
-//# sourceMappingURL=streaming-repair.d.ts.map

package/dist/components/markdown/streaming-repair.js

@@ -1,12 +1,3 @@
-// Mid-stream markdown arrives syntactically unfinished — an open code
-// fence swallows the rest of the answer as code, a dangling ** bolds it,
-// a half-streamed table row renders as prose — and the renderer re-parses
-// on every delta, so each glitch flashes at the reader. This repair
-// closes what the stream will close anyway and holds back what cannot
-// render sensibly yet. Deliberately conservative: only the constructs
-// whose unfinished form is visually loud are touched (fences, inline
-// code, ** strong, table rows); a half-typed link or _emphasis_ renders
-// as plain text harmlessly and is left alone.
 export function repairedStreamingMarkdown(text) {
     let repaired = _withoutAHalfTypedFenceOpener(text);
     if (_endsInsideACodeFence(repaired)) {
@@ -17,9 +8,6 @@ export function repairedStreamingMarkdown(text) {
     repaired = _withStrongEmphasisClosed(repaired);
     return repaired;
 }
-// A fence opener being typed ("`" or "``" alone on the last line) must be
-// held back: counting its backticks would mis-balance inline code and
-// close it into a real fence.
 function _withoutAHalfTypedFenceOpener(text) {
     const lines = text.split("\n");
     const last = lines[lines.length - 1];
@@ -37,8 +25,6 @@ function _endsInsideACodeFence(text) {
     }
     return insideAFence;
 }
-// A table row missing its closing pipe is still streaming; rendered now
-// it would flash as a paragraph and snap into the table a delta later.
 function _withoutAnUnfinishedTrailingTableRow(text) {
     const lines = text.split("\n");
     const last = lines[lines.length - 1];
@@ -57,9 +43,6 @@ function _withStrongEmphasisClosed(text) {
     const strongMarkers = (fenceless.match(/\*\*/g) ?? []).length;
     return strongMarkers % 2 === 1 ? `${text}**` : text;
 }
-// The text with fenced blocks removed, so fence contents never count
-// toward inline balancing. Only called once the trailing fence (if any)
-// is known to be closed.
 function _outsideCodeFences(text) {
     const kept = [];
     let insideAFence = false;
@@ -74,4 +57,3 @@ function _outsideCodeFences(text) {
     }
     return kept.join("\n");
 }
-//# sourceMappingURL=streaming-repair.js.map

package/dist/components/markdown/use-highlighted-html.d.ts

@@ -1,7 +1 @@
-/** The async highlight upgrade both code-block variants ride: null until
- *  (unless) shiki's lazy chunk lands and knows the language — the caller
- *  renders its plain <pre> meanwhile, so a slow or absent chunk is never
- *  a blank block. The result is keyed to its input, so a content change
- *  falls back to plain instantly instead of flashing stale highlights. */
 export declare function useHighlightedHtml(code: string, language: string | null): string | null;
-//# sourceMappingURL=use-highlighted-html.d.ts.map

package/dist/components/markdown/use-highlighted-html.js

@@ -4,11 +4,6 @@ import { highlightToHtml } from "./highlight.js";
 function keyOf(code, language) {
     return `${language} ${code}`;
 }
-/** The async highlight upgrade both code-block variants ride: null until
- *  (unless) shiki's lazy chunk lands and knows the language — the caller
- *  renders its plain <pre> meanwhile, so a slow or absent chunk is never
- *  a blank block. The result is keyed to its input, so a content change
- *  falls back to plain instantly instead of flashing stale highlights. */
 export function useHighlightedHtml(code, language) {
     const [highlighted, setHighlighted] = useState(null);
     useEffect(() => {
@@ -31,4 +26,3 @@ export function useHighlightedHtml(code, language) {
     }
     return highlighted.key === keyOf(code, language) ? highlighted.html : null;
 }
-//# sourceMappingURL=use-highlighted-html.js.map

package/dist/components/markdown/use-paced-reveal.d.ts

@@ -3,4 +3,3 @@ export declare function usePacedReveal(text: string, streaming: boolean): {
     revealed: string;
     revealHostRef: RefObject<HTMLDivElement | null>;
 };
-//# sourceMappingURL=use-paced-reveal.d.ts.map

package/dist/components/markdown/use-paced-reveal.js

@@ -1,11 +1,4 @@
 "use client";
-// The reveal side of the pacer: watches a streaming row's text grow in
-// poll-sized lumps and returns the smoothly-advancing prefix to render.
-// Everything present at mount paints on the first render (a mount is a
-// replay; the first chunk is the first paint — neither is ever delayed),
-// only growth observed while the row streams is paced, and the prefix is
-// raw text — the caller repairs and parses it, so partial markdown is the
-// repair layer's job, not this one's.
 import { useEffect, useRef, useState } from "react";
 import { RevealPacer } from "./reveal-pacer.js";
 const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
@@ -40,8 +33,6 @@ export function usePacedReveal(text, streaming) {
             frameRef.current ??= requestAnimationFrame(advanceRevealLoop);
         };
         if (text.length < previousLength) {
-            // Replaced rather than grown (a resume dedupe edge): pacing a
-            // rewrite would lie about what arrived — show it whole.
             pacerRef.current?.revealInstantly();
             setRevealedLength(text.length);
             return;
@@ -52,9 +43,6 @@ export function usePacedReveal(text, streaming) {
                 setRevealedLength(text.length);
                 return;
             }
-            // Lazily constructed at the first paced growth, but anchored to the
-            // mount time: the gap since mount is what separates a live tail
-            // (~one poll interval) from a replay backlog (back-to-back frames).
             pacerRef.current ??= new RevealPacer(previousLength, mountedAtRef.current);
             pacerRef.current.observe(text.length, now);
             ensureRevealLoop();
@@ -66,22 +54,12 @@ export function usePacedReveal(text, streaming) {
                 setRevealedLength(text.length);
                 return;
             }
-            // The final delta and the terminal often share one network chunk;
-            // React batches the recorder's two publishes into a single commit,
-            // so this effect can see the text grow and the stream end at once.
-            // The growth branch above was skipped (streaming is already false)
-            // — feed the pacer the final length before draining, or the sweep
-            // stops at the previous arrival and the tail never reveals.
             pacerRef.current.observe(text.length, now);
             pacerRef.current.beginDrain(now);
             ensureRevealLoop();
             return;
         }
         if (!streaming) {
-            // A settled row whose text moved without streaming (a park's REST
-            // re-read replacing the stream's partial tail) has no pacer and no
-            // frame loop — this sync is the only writer left.
-            // eslint-disable-next-line react-hooks/set-state-in-effect -- see above; bails out when the length is unchanged
             setRevealedLength(text.length);
         }
     }, [text, streaming]);
@@ -100,23 +78,13 @@ export function usePacedReveal(text, streaming) {
         revealHostRef,
     };
 }
-// A prefix cut between the halves of a surrogate pair leaves a lone
-// surrogate that paints as � for a frame. Backing off one unit stays
-// monotone: the underlying boundary only ever moves forward, so the
-// rounded-down boundary never retreats either.
 function _notSplittingASurrogatePair(text, length) {
     const lastCode = text.charCodeAt(length - 1);
     const cutsAPairInHalf = lastCode >= 0xd800 && lastCode <= 0xdbff;
     return cutsAPairInHalf ? length - 1 : length;
 }
-// Reduced motion is resolved per decision, before any pacer exists — the
-// animating variant is never constructed (the package's motion
-// doctrine). Both channels: the OS media query and the app's
-// data-reduce-motion kill switch, read from the rendered host so the
-// ancestor walk starts inside whatever tree the row mounted in.
 function _reducedMotionIsOnFor(element) {
     return (window.matchMedia(REDUCED_MOTION_QUERY).matches ||
         (element !== null &&
             element.closest('[data-reduce-motion="true"]') !== null));
 }
-//# sourceMappingURL=use-paced-reveal.js.map

package/dist/components/memory-updated-footer.d.ts

@@ -2,4 +2,3 @@ import type { MemoryUpdated } from "../core/memory-provenance-anchors.js";
 export declare function MemoryUpdatedFooter({ updates, }: {
     updates: readonly MemoryUpdated[];
 }): import("react").JSX.Element | null;
-//# sourceMappingURL=memory-updated-footer.d.ts.map

package/dist/components/memory-updated-footer.js

@@ -1,31 +1,9 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// The message-level memory provenance footer: a quiet affordance under
-// the assistant prose whose run caused one or more memory writes. The
-// trigger coalesces the batch into one line ("Memory updated", counted
-// past one write); the reveal lists each write's canned sentence and
-// destination label.
-//
-// Audience decision, recorded where the rendering happens: this footer
-// renders identically on the embedded widget (anonymous visitors) and the
-// dashboard concierge, because the payload is end-user safe BY
-// CONSTRUCTION at the producer — verified, not assumed. The backend's
-// MemoryWritten record is deliberately content-free (memory_id + scope
-// enum only; the serving side's memory store), the emitter interpolates
-// nothing (the summary is always the module constant
-// MEMORY_UPDATED_SUMMARY_SENTENCE at its single construction site, the
-// assistant-turn activity), and the exact payload shape is pinned by the
-// serving side's approval story so an accidental content leak fails CI.
-// This component still narrows at its own layer (the serving pipeline has
-// no marker sanitizer): it renders ONLY the narrowed summary sentence and
-// a generic destination label — never the memory id, raw payloads,
-// storage paths, or an uncapped token.
 import { BrainIcon, ChevronDownIcon } from "lucide-react";
 import { useEffect, useId, useRef, useState } from "react";
 import { TfButton } from "./primitives/button.js";
 import { cx } from "./primitives/cx.js";
-/** The destination label: an open vocabulary rendered generically past
- *  the two known scopes — an unknown token never renders verbatim. */
 function memoryScopeLabelOf(scope) {
     if (scope === "user") {
         return "Your memory";
@@ -35,10 +13,6 @@ function memoryScopeLabelOf(scope) {
     }
     return "Memory";
 }
-/** The trigger's coalesced line: one quiet phrase however many writes
- *  the run made, counted only past one — and the number names its noun
- *  (the transcript's grammar: "3 results", "1 failed", never a bare
- *  count). */
 function memoryFooterLabelOf(count) {
     return count > 1
         ? `Memory updated · ${String(count)} notes`
@@ -49,11 +23,6 @@ export function MemoryUpdatedFooter({ updates, }) {
     const panelId = useId();
     const triggerRef = useRef(null);
     const panelRef = useRef(null);
-    // Light dismissal by composedPath() — the script-tag distribution runs
-    // in an open shadow root, where contains() would misjudge every
-    // in-shadow press (the provider chip's rationale, verbatim). Escape
-    // rides listeners on the trigger and panel (the roster card's idiom)
-    // rather than a handler on the static wrapper.
     useEffect(() => {
         const panelElement = panelRef.current;
         const trigger = triggerRef.current;
@@ -93,11 +62,5 @@ export function MemoryUpdatedFooter({ updates, }) {
     }
     return (_jsxs("div", { "data-tf-memory-footer": "", className: "tf:relative tf:mt-1 tf:w-fit", children: [_jsxs(TfButton, { ref: triggerRef, variant: "bare", "aria-expanded": open, "aria-controls": open ? panelId : undefined, className: "tf:py-1 tf:text-xs tf:text-tf-muted-foreground tf:hover:text-tf-foreground", onClick: () => {
                     setOpen((wasOpen) => !wasOpen);
-                }, children: [_jsx(BrainIcon, { "aria-hidden": true, className: "tf:size-3.5 tf:shrink-0" }), _jsx("span", { children: memoryFooterLabelOf(updates.length) }), _jsx(ChevronDownIcon, { "aria-hidden": true, className: cx("tf:size-3 tf:shrink-0 tf:transition-transform", !open && "tf:-rotate-90") })] }), open ? (
-            // Opens UPWARD (bottom-full), away from the composer, so the
-            // reveal can never cover its controls (TVC-120's posture). The
-            // card is static provenance text, so a note — not a dialog: no
-            // focus trap to manage, Escape and light dismissal close it.
-            _jsx("div", { ref: panelRef, id: panelId, role: "note", "aria-label": "Memory updates", "data-tf-glass": "", className: "tf:absolute tf:bottom-full tf:start-0 tf:mb-1 tf:flex tf:w-72 tf:flex-col tf:rounded-2xl tf:border tf:p-2", children: _jsx("ul", { className: "tf:m-0 tf:flex tf:max-h-64 tf:list-none tf:flex-col tf:overflow-y-auto tf:ps-0", children: updates.map((update) => (_jsxs("li", { "data-tf-memory-entry": "", className: "tf:flex tf:flex-col tf:gap-0.5 tf:px-2 tf:py-1.5", children: [_jsx("span", { className: "tf:text-tf-label tf:text-tf-foreground", children: update.summary }), _jsx("span", { className: "tf:text-xs tf:text-tf-muted-foreground", children: memoryScopeLabelOf(update.scope) })] }, update.memoryId))) }) })) : null] }));
+                }, children: [_jsx(BrainIcon, { "aria-hidden": true, className: "tf:size-3.5 tf:shrink-0" }), _jsx("span", { children: memoryFooterLabelOf(updates.length) }), _jsx(ChevronDownIcon, { "aria-hidden": true, className: cx("tf:size-3 tf:shrink-0 tf:transition-transform", !open && "tf:-rotate-90") })] }), open ? (_jsx("div", { ref: panelRef, id: panelId, role: "note", "aria-label": "Memory updates", "data-tf-glass": "", className: "tf:absolute tf:bottom-full tf:start-0 tf:mb-1 tf:flex tf:w-72 tf:flex-col tf:rounded-2xl tf:border tf:p-2", children: _jsx("ul", { className: "tf:m-0 tf:flex tf:max-h-64 tf:list-none tf:flex-col tf:overflow-y-auto tf:ps-0", children: updates.map((update) => (_jsxs("li", { "data-tf-memory-entry": "", className: "tf:flex tf:flex-col tf:gap-0.5 tf:px-2 tf:py-1.5", children: [_jsx("span", { className: "tf:text-tf-label tf:text-tf-foreground", children: update.summary }), _jsx("span", { className: "tf:text-xs tf:text-tf-muted-foreground", children: memoryScopeLabelOf(update.scope) })] }, update.memoryId))) }) })) : null] }));
 }
-//# sourceMappingURL=memory-updated-footer.js.map

package/dist/components/message-list-row.d.ts

@@ -11,4 +11,3 @@ export declare function Row({ row, cards, turnLive, inCurrentTurn, identityToken
     messageView?: MessageViewSlot;
     toolRow?: ToolRowSlot;
 }): import("react").JSX.Element;
-//# sourceMappingURL=message-list-row.d.ts.map

package/dist/components/message-list-row.js

@@ -11,44 +11,18 @@ import { SubagentGroupRow } from "./subagent-group-row.js";
 import { SurfaceBoundary } from "./surface-boundary.js";
 import { ToolCallRows } from "./tool-call-rows.js";
 import { UserMessage } from "./user-message.js";
-/** THE one slot-fill shape, enforced by construction: every
- *  messageView-eligible arm renders through this helper, whose `children`
- *  IS the package default — one node, used verbatim as the unfilled
- *  rendering, the null-fallthrough, and the boundary's throw fallback. A duplicated
- *  default cannot be written through this seam; writing around it means
- *  spelling HostSlotBoundary + SlotOrDefault by hand, which the slots
- *  suite's byte-parity case (null-filled ≡ unfilled, every kind) catches once the copies diverge. */
 function SwappedContent({ messageView, row, children, }) {
     if (messageView === undefined) {
         return _jsx(_Fragment, { children: children });
     }
     return (_jsx(HostSlotBoundary, { slot: "messageView", fallback: children, children: _jsx(SlotOrDefault, { render: () => messageView(row), fallback: children }) }));
 }
-// THE SLOT-FILL SHAPE, per messageView-eligible kind (the committed
-// enumeration): every kind is shared-frame-with-swapped-content through
-// SwappedContent above.
-//   user              — frame: the py-2 wrapper + pending-echo a11y;
-//                       swapped content: the UserMessage bubble.
-//   assistant-text    — frame: the group wrapper + identity stamp +
-//                       provenance footer + copy affordance (canonical
-//                       order prose → footer → copy on BOTH paths);
-//                       swapped content: the paced markdown.
-//   subagent-group    — no frame element; swapped content: the whole
-//                       package group row.
-//   subagent-delivery — no frame element; swapped content: the whole
-//                       package divider.
 export function Row({ row, cards, turnLive, inCurrentTurn, identityToken, decisionSurfacesInShelf, messageView, toolRow, }) {
     switch (row.kind) {
         case "run-fold":
-            // Not offered to messageView: the fold geometry is package-owned
-            // structure (non-negotiable). The tool rows inside keep their
-            // own toolRow seam.
             return (_jsx(ActivityRail, { fold: row, cards: cards, turnLive: turnLive, inCurrentTurn: inCurrentTurn, identityToken: identityToken, decisionSurfacesInShelf: decisionSurfacesInShelf, toolRow: toolRow }));
         case "user":
-            return (
-            // The wrapper is the frame's: its spacing and the pending-echo
-            // a11y facts are not a slot's to remove.
-            _jsx("div", { className: "tf:py-2", ...(row.optimistic === true
+            return (_jsx("div", { className: "tf:py-2", ...(row.optimistic === true
                     ? {
                         "data-tf-pending-echo": "",
                         role: "status",
@@ -57,37 +31,16 @@ export function Row({ row, cards, turnLive, inCurrentTurn, identityToken, decisi
                     : {}), children: _jsx(SwappedContent, { messageView: messageView, row: row, children: _jsx(UserMessage, { attachments: row.attachments, createdAt: row.createdAt, children: row.text }) }) }));
         case "assistant-text":
             return (_jsx(AssistantProseRow, { row: row, identityToken: identityToken, messageView: messageView }));
-        // No "reasoning" case: DisplayRow excludes it — every reasoning row
-        // is folded into a run fold by runFoldsOf.
         case "tool-call":
-            // Defensive support for a directly supplied tool row; the fold
-            // pass groups all tool calls, including answered asks.
-            return (
-            // Per-row boundary: one poisoned tool row degrades one row; the
-            // list-level boundary stays the backstop. The projection
-            // (_toolViewOf) runs INSIDE ToolCallRows, which this boundary
-            // wraps whole.
-            _jsx(SurfaceBoundary, { surface: "tool-row", children: _jsx(ToolCallRows, { row: row, cards: cards, decisionSurfacesInShelf: decisionSurfacesInShelf, toolRow: toolRow }) }));
+            return (_jsx(SurfaceBoundary, { surface: "tool-row", children: _jsx(ToolCallRows, { row: row, cards: cards, decisionSurfacesInShelf: decisionSurfacesInShelf, toolRow: toolRow }) }));
         case "subagent-group":
             return (_jsx(SwappedContent, { messageView: messageView, row: row, children: _jsx(SubagentGroupRow, { row: row }) }));
         case "subagent-delivery":
             return (_jsx(SwappedContent, { messageView: messageView, row: row, children: _jsx(SubagentDeliveryDivider, { results: row.results }) }));
         case "turn-failed-receipts":
-            // The turn-level terminal state, the ONE standalone receipt row left
-            // after the meta-receipt deletion: a turn that dies mid-way must
-            // still explain itself. Distinct from any single operation's in-row
-            // failure pill.
             return _jsx(TurnFailedReceiptRows, { receipts: row.receipts });
     }
 }
-// The slot swaps only the PROSE; everything else is the frame's, in the one
-// canonical order — prose, provenance, copy.
 function AssistantProseRow({ row, identityToken, messageView, }) {
-    return (
-    // Keep the surface identity token for provenance/reconciliation,
-    // but do not stamp a logo above ordinary prose. Identity belongs
-    // to agent chrome (subagent rows, roster, drill-in), not every
-    // authored paragraph.
-    _jsxs("div", { className: "tf:group/assistant-message tf:py-2", "data-tf-agent-identity": identityToken, children: [_jsx(SwappedContent, { messageView: messageView, row: row, children: _jsx(PacedAssistantMarkdown, { text: row.text, streaming: row.streaming }) }), row.memoryUpdates !== undefined ? (_jsx(MemoryUpdatedFooter, { updates: row.memoryUpdates })) : null, !row.streaming ? (_jsx("div", { className: "tf:flex tf:h-7 tf:items-center", children: _jsx(CopyTextButton, { text: row.text, label: "Copy message", className: "tf:opacity-0 tf:transition-opacity tf:group-hover/assistant-message:opacity-100 tf:group-focus-within/assistant-message:opacity-100 tf:focus-visible:opacity-100 tf:pointer-coarse:opacity-100" }) })) : null] }));
+    return (_jsxs("div", { className: "tf:group/assistant-message tf:py-2", "data-tf-agent-identity": identityToken, children: [_jsx(SwappedContent, { messageView: messageView, row: row, children: _jsx(PacedAssistantMarkdown, { text: row.text, streaming: row.streaming }) }), row.memoryUpdates !== undefined ? (_jsx(MemoryUpdatedFooter, { updates: row.memoryUpdates })) : null, !row.streaming ? (_jsx("div", { className: "tf:flex tf:h-7 tf:items-center", children: _jsx(CopyTextButton, { text: row.text, label: "Copy message", className: "tf:opacity-0 tf:transition-opacity tf:group-hover/assistant-message:opacity-100 tf:group-focus-within/assistant-message:opacity-100 tf:focus-visible:opacity-100 tf:pointer-coarse:opacity-100" }) })) : null] }));
 }
-//# sourceMappingURL=message-list-row.js.map

package/dist/components/message-list-slots.d.ts

@@ -2,44 +2,20 @@ import type { ReactNode } from "react";
 import type { SubagentGroupRow as SubagentGroupRowModel } from "../core/subagent-rows.js";
 import type { ToolCallViewModel } from "../core/tool-call-display.js";
 import type { AssistantTextRow, SubagentDeliveryRow, ToolCallRow, TranscriptBlock, TranscriptRow, UserMessageRow } from "../core/transcript-rows.js";
-/** The marker contract AssistantTranscript's agent mode renders under:
- *  the host composite is invoked twice per message block, before and
- *  after, and self-selects by anchor — the chassis' custom-renderer walk,
- *  owned. */
 export interface TranscriptMarkerProps {
     message: {
         id: string;
     };
     position: "before" | "after";
 }
-/** The row kinds a host messageView may fill. `run-fold`,
- *  `turn-failed-receipts` and `tool-call` rows are deliberately not
- *  offered: the fold geometry and the turn-level failure record are
- *  package-owned structure, and a tool row's seam is the toolRow slot. */
 export type TranscriptSlotRow = UserMessageRow | AssistantTextRow | SubagentGroupRowModel | SubagentDeliveryRow;
-/** What a host toolRow fill receives: the durable projection row (raw
- *  arguments, raw result, the state ladder's answer), the resolved view
- *  the package ToolRow renders from (its output carries the MEMBER
- *  suppressions), and the pending-decision bit. The row rides beside the
- *  view so an operator binder can show the wire evidence the member
- *  surface suppresses — the TVC suppression laws are scoped to the
- *  package rendering. A whole-row seam, never a second view system:
- *  per-tool presentation is the tool-view registry's (tool-views.md). */
 export interface ToolRowSlotProps {
     row: ToolCallRow;
     view: ToolCallViewModel;
     awaitingInput: boolean;
 }
-/** Fill contracts: returning null, undefined, or either boolean falls
- *  through to the package rendering (SlotOrDefault's fall-through rule —
- *  the values React renders as nothing regardless of content, so
- *  `cond && <X/>` declines on the false arm); renderable emptiness
- *  ("", 0, []) counts as a fill. */
 export type MessageViewSlot = (row: TranscriptSlotRow) => ReactNode;
 export type ToolRowSlot = (props: ToolRowSlotProps) => ReactNode;
-/** Exactly one row source — the same discriminated-union shape
- *  AssistantTranscriptProps uses, so a source-less (or double-sourced)
- *  mount is a type error rather than a silently empty log. */
 export type MessageListSource = {
     rows: readonly TranscriptRow[];
     blocks?: never;
@@ -47,4 +23,3 @@ export type MessageListSource = {
     blocks: readonly TranscriptBlock[];
     rows?: never;
 };
-//# sourceMappingURL=message-list-slots.d.ts.map

package/dist/components/message-list-slots.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=message-list-slots.js.map