@kortix/ui 0.14.3 → 0.14.5

package/dist/session/turn/activity-group-step.d.ts

@@ -0,0 +1,101 @@
+import type { ToolCallBlock } from '@kortix/sdk';
+import type { Step } from '@kortix/sdk';
+/**
+ * A run of consecutive same-family calls: one summary row that opens to its
+ * members.
+ *
+ * This is the level the burst has always grouped at. Until this row existed,
+ * expanding a burst of two reads and two commands produced four flat siblings —
+ * the burst counted a grouped story and the expansion told an ungrouped one.
+ *
+ * The group binds to `ChainOfThoughtStep`'s OWN `Disclosure`, so it opens
+ * independently of every other step and the chain rail still spans it however
+ * tall it grows. Trigger and content must be one component rather than two
+ * sibling children of the step: `Disclosure` renders exactly
+ * `React.Children.toArray(children)[0]` and `[1]`, and the step's rail already
+ * claims slot 0 — passing them as siblings would silently drop the content.
+ *
+ * `pl-7` puts the members under the group's LABEL (size-4 icon + gap-3), clear
+ * of the rail at `left-2` — the indent is what says these rows belong to the
+ * row above rather than to the chain.
+ *
+ * The group row is the PARENT of the rows it opens, and says so without colour:
+ * `font-medium` against the regular-weight tool titles underneath it (see
+ * `InlineTriggerTitle` in tool/shared/infrastructure.tsx). Indent alone left the
+ * two levels reading as one list at a glance.
+ *
+ * Failure carries NO icon of its own. `groupSteps` already picks the WORDS —
+ * a group holding a failure gets `narrateFailedStep` ("Couldn't read your
+ * files"), never success wording — and the sentence is the whole signal. The
+ * row keeps its muted family glyph either way; a red warning mark beside a
+ * label that already says "failed" states the verdict twice.
+ *
+ * Running shimmers the label, which is how every tool row in this same chain
+ * already says "still going" — one running vocabulary per surface, not two.
+ */
+declare function ActivityGroupStepImpl({ step, sessionId, disableNavigation, }: {
+    step: Step<ToolCallBlock>;
+    sessionId: string;
+    disableNavigation?: boolean;
+}): import("react").JSX.Element;
+/**
+ * Memo boundaries.
+ *
+ * The chat re-renders the streaming turn on every SSE frame. Without a boundary
+ * that means every burst in that turn, every row in every burst, and every tool
+ * renderer under those rows — including shiki — runs again for parts that did
+ * not change. These boundaries are where the subtree can actually be cut.
+ *
+ * `ActivityBurst` compares `parts` element-wise rather than by identity, because
+ * while a turn streams its segments are rebuilt each frame: the ARRAY is always
+ * new, its contents almost never are. See `same-parts.ts`.
+ *
+ * `ActivityGroupStep` and `ThoughtChainStep` do NOT get a memoised `step` /
+ * `texts` from `mergeBurstSteps` — the default shallow compare does NOT hold
+ * for either, and both need their own element-wise comparator:
+ *
+ *   `mergeBurstSteps`'s `useMemo` in `ActivityBurst` is keyed on `[parts]`, and `parts` is a
+ *   fresh array on every SSE delta of the streaming turn (see `same-parts.ts`).
+ *   That re-runs `mergeBurstSteps` → `groupSteps` → `finalize` for every group
+ *   in the burst, tools that already settled included, and `finalize` builds a
+ *   brand-new `Step` object (and a brand-new `parts` array around the same
+ *   `ToolCallBlock` elements) every time it runs. So `step` is a new object identity
+ *   per delta even when nothing in that particular group changed — the default
+ *   shallow compare fails on `step` alone, and every open group row re-renders
+ *   on every token of an unrelated streaming tool call in the same burst.
+ *   Comparing `step` by its actual content — `status`, `label`, and the
+ *   underlying `parts` element-wise (`samePartsList`, since `finalize` rebuilds
+ *   that array too but reuses the same `ToolCallBlock` objects inside it) — is what
+ *   makes the boundary real. `texts` is exactly the same shape of problem one
+ *   level up: `mergeBurstSteps` pushes a fresh `texts` array per thought run
+ *   on every call, so `ThoughtChainStep` needs the same element-wise rule.
+ *
+ * `ActivityStep` (`activity-step.tsx`) is the one row in this chain where the
+ * default shallow compare DOES hold: it takes `part` directly off the burst's
+ * own `parts` prop — for an unwrapped run of one, `mergeBurstSteps` hands it
+ * `step.parts[0]`, the very call reference from the input array, never a
+ * rebuilt copy. The session store only replaces the ONE part that actually
+ * changed on a given SSE delta and keeps every sibling reference stable, so a
+ * settled tool row's `part` prop keeps its identity across deltas that touch a
+ * different part — `React.memo`'s reference check is correct there without a
+ * custom comparator.
+ *
+ * `ChainOfThought` and `ChainOfThoughtStep` are deliberately NOT memoised: they
+ * take `children`, which is a new element on every parent render, so a boundary
+ * there can never hold and would only add a failed comparison.
+ */
+type ActivityGroupStepProps = {
+    step: Step<ToolCallBlock>;
+    sessionId: string;
+    disableNavigation?: boolean;
+};
+/**
+ * `ActivityGroupStep`'s memo comparator, exported so the boundary itself is
+ * unit-tested rather than only exercised indirectly through a render.
+ *
+ * `step` is compared by content, not identity — see the memo-boundaries
+ * comment above for why identity never holds across an SSE delta.
+ */
+export declare function sameActivityGroupStepProps(a: ActivityGroupStepProps, b: ActivityGroupStepProps): boolean;
+export declare const ActivityGroupStep: import("react").MemoExoticComponent<typeof ActivityGroupStepImpl>;
+export {};

package/dist/session/turn/activity-group-step.js

@@ -0,0 +1,62 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChainOfThought, ChainOfThoughtStep } from '../../primitives/chain-of-thought.js';
+import { DisclosureContent } from '../../primitives/disclosure.js';
+import { TextShimmer } from '../../primitives/text-shimmer.js';
+import { memo } from 'react';
+import { ActivityStep, iconFor } from './activity-step.js';
+import { ChainStepTrigger } from './chain-step-trigger.js';
+import { samePartsList } from './same-parts.js';
+/**
+ * A run of consecutive same-family calls: one summary row that opens to its
+ * members.
+ *
+ * This is the level the burst has always grouped at. Until this row existed,
+ * expanding a burst of two reads and two commands produced four flat siblings —
+ * the burst counted a grouped story and the expansion told an ungrouped one.
+ *
+ * The group binds to `ChainOfThoughtStep`'s OWN `Disclosure`, so it opens
+ * independently of every other step and the chain rail still spans it however
+ * tall it grows. Trigger and content must be one component rather than two
+ * sibling children of the step: `Disclosure` renders exactly
+ * `React.Children.toArray(children)[0]` and `[1]`, and the step's rail already
+ * claims slot 0 — passing them as siblings would silently drop the content.
+ *
+ * `pl-7` puts the members under the group's LABEL (size-4 icon + gap-3), clear
+ * of the rail at `left-2` — the indent is what says these rows belong to the
+ * row above rather than to the chain.
+ *
+ * The group row is the PARENT of the rows it opens, and says so without colour:
+ * `font-medium` against the regular-weight tool titles underneath it (see
+ * `InlineTriggerTitle` in tool/shared/infrastructure.tsx). Indent alone left the
+ * two levels reading as one list at a glance.
+ *
+ * Failure carries NO icon of its own. `groupSteps` already picks the WORDS —
+ * a group holding a failure gets `narrateFailedStep` ("Couldn't read your
+ * files"), never success wording — and the sentence is the whole signal. The
+ * row keeps its muted family glyph either way; a red warning mark beside a
+ * label that already says "failed" states the verdict twice.
+ *
+ * Running shimmers the label, which is how every tool row in this same chain
+ * already says "still going" — one running vocabulary per surface, not two.
+ */
+function ActivityGroupStepImpl({ step, sessionId, disableNavigation, }) {
+    const Icon = iconFor(step.parts[0]);
+    return (_jsxs(_Fragment, { children: [_jsx(ChainStepTrigger, { status: step.status, icon: _jsx(Icon, { className: "text-muted-foreground size-4 flex-none" }), label: step.status === 'running' ? (_jsx(TextShimmer, { className: "min-w-0 truncate leading-[1.5] font-medium", children: step.label })) : (_jsx("span", { className: "min-w-0 truncate font-medium", children: step.label })) }), _jsx(DisclosureContent, { children: _jsx("div", { className: "mt-3 pl-7", children: _jsx(ChainOfThought, { children: step.parts.map((call) => (_jsx(ChainOfThoughtStep, { children: _jsx(ActivityStep, { call: call, sessionId: sessionId, disableNavigation: disableNavigation }) }, call.id))) }) }) })] }));
+}
+/**
+ * `ActivityGroupStep`'s memo comparator, exported so the boundary itself is
+ * unit-tested rather than only exercised indirectly through a render.
+ *
+ * `step` is compared by content, not identity — see the memo-boundaries
+ * comment above for why identity never holds across an SSE delta.
+ */
+export function sameActivityGroupStepProps(a, b) {
+    return (a.sessionId === b.sessionId &&
+        a.disableNavigation === b.disableNavigation &&
+        a.step.status === b.step.status &&
+        a.step.label === b.step.label &&
+        samePartsList(a.step.parts, b.step.parts));
+}
+export const ActivityGroupStep = memo(ActivityGroupStepImpl, sameActivityGroupStepProps);
+ActivityGroupStep.displayName = 'ActivityGroupStep';

package/dist/session/turn/activity-step.d.ts

@@ -0,0 +1,34 @@
+import type { ToolCallBlock } from '@kortix/sdk';
+import type { StepLabel } from '@kortix/sdk';
+/** Exported so a group row can lead with the same glyph its members carry. */
+export declare function iconFor(call: ToolCallBlock): import("react").ComponentType<{
+    className?: string;
+}>;
+/**
+ * The label row of a step that is not a tool call: its glyph, verb and object.
+ * The turn modules share a "never silently drop a part" policy, so a part that
+ * is neither tool nor reasoning still gets this row (`StepBody`).
+ */
+export declare function StepLabelRow({ label, running, bare, }: {
+    label: StepLabel;
+    running: boolean;
+    bare?: boolean;
+}): import("react").JSX.Element;
+declare function ActivityStepImpl({ call, sessionId, disableNavigation, bare, }: {
+    call: ToolCallBlock;
+    sessionId: string;
+    disableNavigation?: boolean;
+    /**
+     * This row is the WHOLE burst — no summary line above it, no siblings, no
+     * chain rail. See `ActivityBurst`.
+     */
+    bare?: boolean;
+}): import("react").JSX.Element;
+/**
+ * Every prop here is a scalar or the call itself, and a call keeps its identity
+ * until it changes — so the default shallow compare is exactly right, and this
+ * is the boundary that stops a settled tool row (and its shiki-highlighted
+ * card) from re-rendering on every frame of the turn it sits in.
+ */
+export declare const ActivityStep: import("react").MemoExoticComponent<typeof ActivityStepImpl>;
+export {};

package/dist/session/turn/activity-step.js

@@ -0,0 +1,116 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** One row inside a burst: icon, verb, object, and the tool's own result. */
+import { FilesIcon, FolderOpenIcon, GlobeIcon, MagnifyingGlassIcon, PencilSimpleIcon, ReadCvLogoIcon, StackIcon, TerminalWindowIcon, UsersThreeIcon, } from '@phosphor-icons/react';
+import { familyForTool } from '@kortix/sdk';
+import { partOutcome } from '@kortix/sdk';
+import { ToolPartRenderer } from '../tool/tool-renderers.js';
+import { cn } from '../../lib/utils.js';
+import { memo } from 'react';
+import { normalizeActivityToolName } from '@kortix/sdk';
+const ICONS = {
+    read: ReadCvLogoIcon,
+    write: PencilSimpleIcon,
+    edit: PencilSimpleIcon,
+    apply_patch: PencilSimpleIcon,
+    bash: TerminalWindowIcon,
+    glob: MagnifyingGlassIcon,
+    grep: MagnifyingGlassIcon,
+    list: FolderOpenIcon,
+    web_search: GlobeIcon,
+    websearch: GlobeIcon,
+    webfetch: GlobeIcon,
+    web_fetch: GlobeIcon,
+    scrape: GlobeIcon,
+    scrape_webpage: GlobeIcon,
+    task: UsersThreeIcon,
+    // Without an entry here `skill` fell through to the generic `StackIcon`
+    // fallback — the same mark every unrecognised tool gets, so a skills row said
+    // nothing more than "some tool ran". `Files` is stacked pages: several of a
+    // thing, which is exactly what a grouped skills row is.
+    skill: FilesIcon,
+};
+/** Exported so a group row can lead with the same glyph its members carry. */
+export function iconFor(call) {
+    return ICONS[normalizeActivityToolName(call.name)] ?? StackIcon;
+}
+/**
+ * The label row of a step that is not a tool call: its glyph, verb and object.
+ * The turn modules share a "never silently drop a part" policy, so a part that
+ * is neither tool nor reasoning still gets this row (`StepBody`).
+ */
+export function StepLabelRow({ label, running, bare, }) {
+    return (_jsx("div", { className: "min-w-0", children: _jsxs("div", { className: "flex min-w-0 items-center gap-3", children: [!bare && _jsx(StackIcon, { className: "text-muted-foreground size-4 flex-none" }), _jsx("span", { className: "text-foreground/80 flex-none text-sm leading-[1.5]", children: running ? label.running : label.verb }), label.object && (_jsx("span", { className: "text-muted-foreground/70 min-w-0 truncate font-mono text-sm leading-[1.5]", title: label.object, children: label.object }))] }) }));
+}
+function ActivityStepImpl({ call, sessionId, disableNavigation, bare, }) {
+    /**
+     * A bare row drops its leading glyph.
+     *
+     * The family icon is not a label — it is the rail's anchor. `ChainOfThought`
+     * runs its connector down the centre of that 16px gutter (`left-2`), so the
+     * icons are what make a chain read as one thread rather than as loose lines.
+     * A single row has no rail and no thread, so the glyph is left holding a
+     * column that no longer exists, and it pushes the only words on the row 28px
+     * off the margin every other line of the turn starts at.
+     *
+     * The OUTCOME mark is not dropped, and that is the whole subtlety: on a bare
+     * row it is the only failure signal left — the summary line that said
+     * "1 step failed" and the chain's closing step are both gone. `partOutcome`
+     * decides, not `state.status`, so a call that RETURNED its error keeps its
+     * mark too.
+     *
+     * Neither is a DELEGATE row's glyph, for the reason the paragraph above gives
+     * and not despite it. "A single row has no rail and no thread" is true of a
+     * read or a command; it is false of a sub-agent. `task` / `agent_spawn` /
+     * `session_spawn` render a nested thread of their own — the sub-agent's steps,
+     * with their own hairline (`tool/shared/sub-agent.tsx`) — so the row IS a
+     * parent, and the icon is that thread's anchor exactly as it is in the chain.
+     * Stripping it left a lone sub-agent's twenty rows hanging off a line of bare
+     * text. The family table decides rather than a local list of tool names, so a
+     * new delegation alias cannot land on one side of this and not the other.
+     */
+    const hideIcon = Boolean(bare) && partOutcome(call) === 'ok' && familyForTool(call.name) !== 'delegate';
+    // The tool's own renderer is the row: it draws its own icon, title, subtitle,
+    // and duration, and is itself expandable for the full output. A label row on
+    // top of it would just repeat the same step in different words.
+    //
+    // The overrides below touch only the trigger LABEL — icon, title, subtitle,
+    // args, badge, duration — never the expanded content underneath (a code
+    // viewer, terminal output, a search-result list). Those already carry their
+    // own considered typography; forcing them to this row's scale would bloat a
+    // code block and blur the density that makes long output scannable. Scoped
+    // to `[data-component='tool-trigger']` so the Action Panel and /debug/tools,
+    // which render the exact same tool components, are untouched — this is a
+    // reading of the chain, not a change to the tool.
+    //
+    // A trigger favicon (web fetch) is 20px where every other step leads with a
+    // 16px stroke icon, so left alone it sits wider than its neighbours and the
+    // connector line reads as crooked. Pull it to 16px — but only in the trigger.
+    // Source rows nested inside the results card are a separate surface with
+    // their own alignment, and shrinking their favicons to match the chain would
+    // make the card look starved.
+    return (_jsx("div", { className: cn('min-w-0', "[&_[data-component='tool-trigger']]:!gap-3", "[&_[data-component='tool-trigger']>span:first-child>svg]:!size-4", "[&_[data-component='tool-trigger']_span]:!text-sm", "[&_[data-component='tool-trigger']_span]:!leading-[1.5]", "[&_[data-component='tool-trigger']_[data-slot='favicon-avatar']]:!size-4", "[&_[data-component='tool-trigger']_[data-slot='favicon-avatar']_svg]:!size-2.5", 
+        // The tool's leading glyph lives in the trigger's first span
+        // (`ToolHeaderRow`'s `leading`). Scoped to the trigger, so the expanded
+        // content — and the Action Panel rendering the same component — keep
+        // theirs. `hideIcon` has already spared the outcome mark.
+        hideIcon && "[&_[data-component='tool-trigger']>span:first-child]:hidden", 
+        // The gap above moves the trigger's TEXT column; this moves the card
+        // under it to the same place. `TOOL_INDENT` derives 22px from the row's
+        // native `gap-1.5`, so overriding the gap and not the indent is what
+        // left an expanded command's block 6px left of every other row's
+        // content in the same chain. One override is half an override.
+        //
+        // 1.75rem = the 16px icon + the 12px `gap-3` above. A bare row hides the
+        // icon but keeps this: the chain rail still runs at `left-2`, so a card
+        // at the margin would have the hairline cutting through it.
+        '[--tool-indent:1.75rem]'), children: _jsx(ToolPartRenderer, { call: call, sessionId: sessionId, disableNavigation: disableNavigation }) }));
+}
+/**
+ * Every prop here is a scalar or the call itself, and a call keeps its identity
+ * until it changes — so the default shallow compare is exactly right, and this
+ * is the boundary that stops a settled tool row (and its shiki-highlighted
+ * card) from re-rendering on every frame of the turn it sits in.
+ */
+export const ActivityStep = memo(ActivityStepImpl);
+ActivityStep.displayName = 'ActivityStep';

package/dist/session/turn/answered-question-step.d.ts

@@ -0,0 +1,15 @@
+import { type ToolCallBlock } from '@kortix/sdk';
+/**
+ * True when this call has a renderable Q&A: a `question` call with both the
+ * questions asked and the user's answers. Anything less (pending, dismissed,
+ * malformed) falls through to the generic tool row instead.
+ */
+export declare function isAnsweredQuestionCall(call: ToolCallBlock): boolean;
+declare function AnsweredQuestionStepImpl({ call }: {
+    call: ToolCallBlock;
+    bare?: boolean;
+}): import("react").JSX.Element;
+/** Same boundary as `ActivityStep`: the call keeps its identity until it
+ *  changes, so the default shallow compare holds. */
+export declare const AnsweredQuestionStep: import("react").MemoExoticComponent<typeof AnsweredQuestionStepImpl>;
+export {};

package/dist/session/turn/answered-question-step.js

@@ -0,0 +1,58 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useTranslations } from '../../i18n/index.js';
+/**
+ * An answered question as a row inside a burst.
+ *
+ * Answered questions used to render as a standalone card, which force-split the
+ * burst around them: the turn read as burst → card → burst, and the card's
+ * outlined panel was the loudest surface in a list of muted rows. But an
+ * answered question IS a step of the turn — the agent asked, the user answered,
+ * the work continued — so it renders like every other step: a chain row
+ * ("Questions · 3 answered") that opens in place to the Q&A pairs.
+ *
+ * Shaped exactly like `ActivityGroupStep`: one component returning trigger +
+ * content, rendered inside a `ChainOfThoughtStep` whose own `Disclosure` it
+ * binds to. Trigger and content must be ONE child — `Disclosure` renders
+ * exactly slots [0] and [1], and the step's rail already claims a slot, so as
+ * siblings the content is silently dropped.
+ */
+import { UnifiedMarkdown } from '../../markdown/unified-markdown.js';
+import { DisclosureContent } from '../../primitives/disclosure.js';
+import { toToolView } from '@kortix/sdk';
+import { ChatTeardropTextIcon } from '@phosphor-icons/react';
+import { memo } from 'react';
+import { isQuestionTool } from '@kortix/sdk';
+import { ChainStepTrigger } from './chain-step-trigger.js';
+function readQuestions(call) {
+    const input = call.input;
+    return Array.isArray(input?.questions) ? input.questions : [];
+}
+function readAnswers(call) {
+    return toToolView(call).answers ?? [];
+}
+/**
+ * True when this call has a renderable Q&A: a `question` call with both the
+ * questions asked and the user's answers. Anything less (pending, dismissed,
+ * malformed) falls through to the generic tool row instead.
+ */
+export function isAnsweredQuestionCall(call) {
+    if (!isQuestionTool(call.name))
+        return false;
+    return readQuestions(call).length > 0 && readAnswers(call).length > 0;
+}
+function AnsweredQuestionStepImpl({ call }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const questions = readQuestions(call);
+    const answers = readAnswers(call);
+    const answeredCount = answers.filter((a) => a.length > 0).length;
+    return (_jsxs(_Fragment, { children: [_jsx(ChainStepTrigger, { icon: _jsx(ChatTeardropTextIcon, { className: "text-muted-foreground size-4 flex-none" }), label: _jsx("span", { className: "font-medium", children: tI18nComplete.raw('text9a72221a2747') }), trailing: _jsxs("span", { className: "text-muted-foreground tabular-nums", children: [answeredCount, " ", tI18nComplete.raw('text68c780cd132a')] }) }), _jsx(DisclosureContent, { children: _jsx("div", { className: "mt-3 space-y-2 pl-7", children: questions.map((q, i) => {
+                        const answer = answers[i] || [];
+                        const answerText = answer.join(', ') || tI18nComplete.raw('text7e49c68db30e');
+                        return (_jsxs("div", { className: "space-y-0.5", children: [_jsx("div", { className: "[&_*]:!text-muted-foreground [&_strong]:!text-muted-foreground [&_code]:!text-xs [&_li]:!my-0 [&_ol]:!my-0 [&_p]:!my-0 [&_p]:!text-xs [&_p]:!leading-relaxed [&_p]:!text-pretty [&_ul]:!my-0", children: _jsx(UnifiedMarkdown, { content: q.question, trust: "agent" }) }), _jsx("p", { className: "text-foreground text-sm font-medium text-pretty", children: answerText })] }, q.question));
+                    }) }) })] }));
+}
+/** Same boundary as `ActivityStep`: the call keeps its identity until it
+ *  changes, so the default shallow compare holds. */
+export const AnsweredQuestionStep = memo(AnsweredQuestionStepImpl);
+AnsweredQuestionStep.displayName = 'AnsweredQuestionStep';

package/dist/session/turn/attachment-preview.d.ts

@@ -0,0 +1,7 @@
+/** Stored attachments have their own bytes, not a path in a running sandbox. */
+export declare function AttachmentPreview({ name, mime, load, onClose, }: {
+    name: string;
+    mime: string;
+    load: () => Promise<Blob>;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/session/turn/attachment-preview.js

@@ -0,0 +1,46 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import Loading from '../../primitives/loading.js';
+import { Modal, ModalContent, ModalHeader, ModalTitle } from '../../primitives/modal.js';
+import { PdfRenderer } from '../../files/renderers/pdf/pdf-renderer.js';
+import { getFileCategory } from '../../files/viewer/preview-policy.js';
+import { useTranslations } from '../../i18n/index.js';
+import { downloadBlob } from '../../internal/lib/utils/download.js';
+import { useEffect, useState } from 'react';
+import { PastedTextBody } from '../composer/pasted-text.js';
+/** Stored attachments have their own bytes, not a path in a running sandbox. */
+export function AttachmentPreview({ name, mime, load, onClose, }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    const [blob, setBlob] = useState(null);
+    const [text, setText] = useState(null);
+    const [url, setUrl] = useState(null);
+    const [error, setError] = useState(null);
+    const category = getFileCategory(name, mime);
+    useEffect(() => {
+        let cancelled = false;
+        let objectUrl;
+        void load()
+            .then(async (bytes) => {
+            const content = category === 'pdf' ? null : await bytes.text();
+            if (cancelled)
+                return;
+            setBlob(bytes);
+            setText(content);
+            if (category === 'pdf') {
+                objectUrl = URL.createObjectURL(bytes);
+                setUrl(objectUrl);
+            }
+        })
+            .catch((reason) => {
+            if (!cancelled)
+                setError(reason instanceof Error ? reason.message : String(reason));
+        });
+        return () => {
+            cancelled = true;
+            if (objectUrl)
+                URL.revokeObjectURL(objectUrl);
+        };
+    }, [load, category]);
+    return (_jsx(Modal, { open: true, onOpenChange: (open) => !open && onClose(), children: _jsxs(ModalContent, { className: "flex max-h-[85svh] flex-col overflow-hidden lg:max-w-3xl", children: [_jsx(ModalHeader, { children: _jsx(ModalTitle, { children: name }) }), _jsx("div", { className: "min-h-0 flex-1 overflow-auto px-5 pb-5", children: error ? (_jsx("p", { role: "alert", children: error })) : !blob ? (_jsx(Loading, {})) : category === 'pdf' ? (_jsx("div", { className: "h-[65svh]", children: _jsx(PdfRenderer, { url: url, fileName: name, showDownload: false }) })) : (_jsx(PastedTextBody, { text: text ?? '' })) }), _jsx("div", { className: "px-5 pb-5", children: _jsx(Button, { "aria-label": t.raw('textd6eafe823591'), disabled: !blob, onClick: () => blob && downloadBlob(blob, name), children: t.raw('textd6eafe823591') }) })] }) }));
+}

package/dist/session/turn/burst-step-body.d.ts

@@ -0,0 +1,20 @@
+import type { SessionLogBurstStep } from '@kortix/sdk';
+/**
+ * One step's body, without the chain wrapper.
+ * Shared by the chain and by the bare single-step burst, so the two can never
+ * draw the same row two different ways.
+ *
+ * `bare` is not styling — it says the row is the ONLY thing here, which is
+ * what makes the leading glyph pointless (see `ActivityStep`) and what lets a
+ * file-chip run with no chips fall back to the plain tool row instead of
+ * drawing a "Read 1 file" door in front of it.
+ */
+export declare function StepBody({ step, bareRow, running, sessionId, disableNavigation, }: {
+    step: Exclude<SessionLogBurstStep, {
+        kind: 'thought';
+    }>;
+    bareRow?: boolean;
+    running: boolean;
+    sessionId: string;
+    disableNavigation?: boolean;
+}): import("react").JSX.Element;

package/dist/session/turn/burst-step-body.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { normalizeActivityToolName } from '@kortix/sdk';
+import { ActivityFileChipStep, isFileChipCall } from './activity-file-chips.js';
+import { ActivityGroupStep } from './activity-group-step.js';
+import { ActivityStep, StepLabelRow } from './activity-step.js';
+import { AnsweredQuestionStep, isAnsweredQuestionCall } from './answered-question-step.js';
+import { stepLabel } from '@kortix/sdk';
+import { CompactionMarker } from './compaction-card.js';
+import { ToolRegistry } from '../tool/shared/registry.js';
+/** A host's `ToolRegistry.register` row for this tool wins over the chip and question rows. */
+const hostRow = (call) => ToolRegistry.replaced(call.name, call.kind);
+/**
+ * True when this run is entirely one file family, so it can render as chips.
+ *
+ * `isFileChipCall` alone is not enough at a group row. `groupSteps` buckets by
+ * NARRATION family, and `explore` holds `glob`/`grep`/`list` beside `read`
+ * while `edit` holds `edit`/`apply_patch` beside `write` — so a run of two
+ * reads and a grep arrives here as one group. Requiring the same normalized
+ * tool name throughout keeps a grep out of a row whose only vocabulary is
+ * files, and keeps `edit`/`apply_patch` on their diff renderer.
+ */
+function isFileChipRun(calls) {
+    const first = calls[0];
+    if (!first || !isFileChipCall(first) || calls.some(hostRow))
+        return false;
+    const name = normalizeActivityToolName(first.name);
+    return calls.every((call) => isFileChipCall(call) && normalizeActivityToolName(call.name) === name);
+}
+/**
+ * One step's body, without the chain wrapper.
+ * Shared by the chain and by the bare single-step burst, so the two can never
+ * draw the same row two different ways.
+ *
+ * `bare` is not styling — it says the row is the ONLY thing here, which is
+ * what makes the leading glyph pointless (see `ActivityStep`) and what lets a
+ * file-chip run with no chips fall back to the plain tool row instead of
+ * drawing a "Read 1 file" door in front of it.
+ */
+export function StepBody({ step, bareRow = false, running, sessionId, disableNavigation, }) {
+    if (step.kind === 'group') {
+        // Files, not tool cards, when the whole run is reads or writes. The choice
+        // is made here rather than in the burst steps so the merge rules stay
+        // pure and their unwrap-a-run-of-one rule is untouched — which is also why
+        // the single-call branch below can reach the same row.
+        const calls = step.blocks;
+        return isFileChipRun(calls) ? (_jsx(ActivityFileChipStep, { calls: calls, sessionId: sessionId, disableNavigation: disableNavigation })) : (_jsx(ActivityGroupStep, { step: { id: calls[0].call_id, family: step.family, label: step.label, parts: calls, status: step.status, durationMs: step.durationMs }, sessionId: sessionId, disableNavigation: disableNavigation }));
+    }
+    if (step.block.type === 'compaction') {
+        return _jsx(CompactionMarker, { running: running && step.block.summary === null, summary: step.block.summary ?? undefined });
+    }
+    // Neither tool nor reasoning: the label row only. The turn modules never
+    // silently drop a block (`stepLabel` falls back to a generic 'Used' label).
+    if (step.block.type !== 'tool_call') {
+        return _jsx(StepLabelRow, { label: stepLabel(step.block), running: running, bare: bareRow });
+    }
+    const call = step.block;
+    // An answered question renders as its own chain row — "Questions · N
+    // answered", opening in place — never as the generic tool card.
+    if (isAnsweredQuestionCall(call) && !hostRow(call)) {
+        return _jsx(AnsweredQuestionStep, { call: call, bare: bareRow });
+    }
+    // A run of one read is unwrapped into a flat row by the burst steps, which
+    // is right for a shell command and wrong here: one file is still a file.
+    if (isFileChipCall(call) && !hostRow(call)) {
+        return (_jsx(ActivityFileChipStep, { calls: [call], bare: bareRow, sessionId: sessionId, disableNavigation: disableNavigation }));
+    }
+    return (_jsx(ActivityStep, { call: call, bare: bareRow, sessionId: sessionId, disableNavigation: disableNavigation }));
+}

package/dist/session/turn/burst-summary-trigger.d.ts

@@ -0,0 +1,7 @@
+export declare function BurstSummaryTrigger({ bare, running, title, scope, }: {
+    bare: boolean;
+    running: boolean;
+    title: string;
+    /** The named group of the enclosing `Disclosure` root. */
+    scope?: 'burst' | 'work';
+}): import("react").JSX.Element;

package/dist/session/turn/burst-summary-trigger.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { DisclosureTrigger } from '../../primitives/disclosure.js';
+import { TextShimmer } from '../../primitives/text-shimmer.js';
+import { cn } from '../../lib/utils.js';
+import { CaretRightIcon } from '@phosphor-icons/react';
+/**
+ * Static class strings per scope. Tailwind named groups match ANY ancestor, so
+ * the turn's "Worked for" row (`group/work`) cannot share `group/burst`: its
+ * open state would rotate every burst caret nested inside it.
+ */
+const CARET_SCOPE = {
+    burst: 'group-hover/burst:text-muted-foreground/70 group-data-[state=open]/burst:rotate-90',
+    work: 'group-hover/work:text-muted-foreground/70 group-data-[state=open]/work:rotate-90',
+};
+export function BurstSummaryTrigger({ bare, running, title, scope = 'burst', }) {
+    return (_jsx(_Fragment, { children: _jsx(DisclosureTrigger, { className: "select-none", children: bare ? (_jsx("div", { className: "hidden", "aria-hidden": true })) : (_jsxs("div", { className: cn('text-muted-foreground/70 hover:text-muted-foreground', 'flex w-full cursor-pointer items-center gap-2', 'text-left text-sm transition-colors'), children: [running ? (_jsx(TextShimmer, { className: cn('min-w-0 truncate tabular-nums', '[--base-color:color-mix(in_oklch,var(--muted-foreground)_55%,transparent)] [--base-gradient-color:var(--muted-foreground)]', 'dark:[--base-color:color-mix(in_oklch,var(--muted-foreground)_55%,transparent)] dark:[--base-gradient-color:var(--muted-foreground)]'), children: title })) : (_jsx("span", { className: "min-w-0 truncate tabular-nums", children: title })), _jsx(CaretRightIcon, { className: cn('text-muted-foreground/40 size-3.5 flex-none transition-[transform,color]', CARET_SCOPE[scope]) })] })) }) }));
+}

package/dist/session/turn/chain-step-trigger.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export declare function ChainStepTrigger({ icon, label, trailing, status, }: {
+    icon: ReactNode;
+    label: ReactNode;
+    trailing?: ReactNode;
+    status?: string;
+}): import("react").JSX.Element;

package/dist/session/turn/chain-step-trigger.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DisclosureTrigger } from '../../primitives/disclosure.js';
+import { cn } from '../../lib/utils.js';
+import { CaretRightIcon } from '@phosphor-icons/react';
+export function ChainStepTrigger({ icon, label, trailing, status, }) {
+    return (_jsx(DisclosureTrigger, { children: _jsxs("div", { "data-status": status, className: cn('text-foreground/80 hover:text-foreground', 'flex w-full cursor-pointer items-center gap-3', 'text-left text-sm leading-[1.5] transition-colors'), children: [icon, label, trailing, _jsx(CaretRightIcon, { className: cn('text-muted-foreground/40 size-3.5 flex-none', 'transition-transform group-data-[state=open]/step:rotate-90') })] }) }));
+}

package/dist/session/turn/channel-brand.d.ts

@@ -0,0 +1,22 @@
+import type { UiTranslator } from '../../i18n/index.js';
+import type { ChannelPlatform } from './channel-message.js';
+/**
+ * One source for how a chat channel is drawn in a session: its mark and its
+ * brand hue. Used by the incoming channel card (`user-message.tsx`) and by the
+ * outgoing reply card the bash tool renders for `teams send` / `slack send` /
+ * `telegram send` (`tool/tools/channel-send-card.tsx`), so a message and its
+ * reply carry the same badge.
+ *
+ * The hues are the platforms' own brand colors, not themeable tokens — which
+ * is why they live here as named constants rather than as classes. Slack has
+ * none to tint a label with: its mark is four colors and its wordmark is the
+ * text color, black or white. It was Material pink (#E91E63).
+ */
+export declare const CHANNEL_BRAND_COLOR: Record<ChannelPlatform, string | undefined>;
+/** The platform's own mark, in its brand colors. */
+export declare function ChannelBrandMark({ platform, className, }: {
+    platform: ChannelPlatform;
+    className?: string;
+}): import("react").JSX.Element;
+/** The platform's display name; only Teams has a catalog string (its full name). */
+export declare function channelPlatformLabel(platform: ChannelPlatform, tI18nComplete: UiTranslator): string;