@kortix/ui 0.14.3 → 0.14.4

package/dist/session/composer/menus/slash-items.js

@@ -0,0 +1,168 @@
+import { filterSlashActions, SLASH_ACTIONS } from './slash-actions.js';
+import { filterSlashFiles } from './slash-files.js';
+const BUCKET_HEADING = {
+    skill: 'Skills',
+    mcp: 'MCP',
+    command: 'Commands',
+};
+/**
+ * Fixed render order for the command buckets: Skills, then plain Commands,
+ * then MCP.
+ *
+ * MCP moved from the middle to the end. Skills and Commands are things the
+ * user or the project authored and reaches for by name; MCP rows arrive from
+ * whatever servers happen to be connected and are the least likely to be what
+ * someone opened the palette to find, so they sit furthest from the caret.
+ */
+const BUCKET_ORDER = ['skill', 'command', 'mcp'];
+function bucketFor(command) {
+    if (command.source === 'skill')
+        return 'skill';
+    if (command.source === 'mcp')
+        return 'mcp';
+    return 'command';
+}
+/**
+ * Groups Commands rows by `Command.source` ("command" | "mcp" | "skill" |
+ * undefined — `@opencode-ai/sdk` `dist/v2/gen/types.gen.d.ts:1974`) into
+ * Skills / MCP / Commands headings. Nothing upstream filters on `source`, so
+ * skill-backed commands already arrive through `command.list()` mixed in with
+ * everything else; this is what gives them their own heading.
+ *
+ * Every group carries its OWN bucket's heading, including when only one bucket
+ * is non-empty. An earlier version collapsed the single-bucket case onto a flat
+ * "Commands" heading, to avoid a lone "Skills" heading with nothing to contrast
+ * against. That reasoned about the UNFILTERED list only, and it produced a
+ * visible bug the moment a query narrowed the list: typing `/web` against a
+ * real workspace (skills + plain commands) dropped every non-skill row, which
+ * left one non-empty bucket, which relabelled the SAME rows from "Skills" to
+ * "Commands" mid-keystroke. A heading that changes identity while you type
+ * reads as the list having been replaced. Observed on a live session at
+ * localhost:13400 — the rows under it were byte-identical before and after.
+ *
+ * The lone-heading case the old rule guarded against is not a defect: a list of
+ * only skills labelled "Skills" is accurate, and it is what the reference UX
+ * shows. `source: undefined` still lands in the `command` bucket and still
+ * renders "Commands", so a server that never populates `source` is unaffected.
+ */
+export function groupCommandsBySource(commands) {
+    if (commands.length === 0)
+        return [];
+    const buckets = { skill: [], mcp: [], command: [] };
+    for (const command of commands)
+        buckets[bucketFor(command)].push(command);
+    return BUCKET_ORDER.filter((bucket) => buckets[bucket].length > 0).map((bucket) => ({
+        heading: BUCKET_HEADING[bucket],
+        commands: buckets[bucket],
+    }));
+}
+function commandMatchesQuery(command, q) {
+    return ((command.name || '').toLowerCase().includes(q) ||
+        (command.description || '').toLowerCase().includes(q));
+}
+/** Heading for the files the agent MADE — the Outputs card's own word. */
+const OUTPUTS_HEADING = 'Outputs';
+/** Heading for the files the agent READ — the Context card's own word. */
+const CONTEXT_HEADING = 'Context';
+/**
+ * File rows per section once a query narrows the list.
+ *
+ * Matches the `@` menu's own `FILE_LIMIT` (`menu-items.ts`) so the two
+ * palettes cannot disagree about how many files a search is worth.
+ */
+const FILE_LIMIT = 20;
+/**
+ * File rows per section on a bare `/`, before anything is typed.
+ *
+ * Lower than `FILE_LIMIT` on purpose. A long session produces dozens of
+ * files, and listing all of them above Skills/Commands would bury every
+ * command behind a scroll — the palette's fixed rows are what make it land in
+ * a predictable place. Six is enough to show that the session's files ARE
+ * here; typing one character lifts the cap to `FILE_LIMIT` and reaches the
+ * rest.
+ */
+const FILE_PREVIEW_LIMIT = 6;
+/**
+ * Combines OpenCode commands (grouped by source, see `groupCommandsBySource`
+ * above) with composer actions (`slash-actions.ts`) and the session's own
+ * files (`slash-files.ts`) into one flat, contiguously-indexed row list —
+ * mirrors `buildMentionSections`'s contract for the `@` menu
+ * (`menu-items.ts`): one `index` counter threaded across every section in
+ * render order, ready for `moveSelection`/`clampSelection`.
+ */
+export function buildSlashSections({ commands, actions = SLASH_ACTIONS, files = [], actionsHeading = 'Actions', query, }) {
+    const q = query.toLowerCase().trim();
+    const filteredCommands = q ? commands.filter((c) => commandMatchesQuery(c, q)) : commands;
+    const filteredActions = filterSlashActions(actions, query);
+    const filteredFiles = filterSlashFiles(files, query);
+    const fileCap = q ? FILE_LIMIT : FILE_PREVIEW_LIMIT;
+    // Render order: Actions, Outputs, Context, Skills, Commands, MCP.
+    //
+    // Actions moved from last to first. They are the fixed, always-present rows
+    // (switch model, attach a file, …) — the same six every time, in the same
+    // place — while the command sections below them change with the project and
+    // with what is connected. Putting the stable set at the top is what makes
+    // the palette land in a predictable spot instead of one that shifts as
+    // skills are added.
+    //
+    // `index` is assigned in this order and nowhere else: it is a single flat
+    // counter threaded across every section, and `MenuNavState`'s ↑/↓ wrapping
+    // plus `aria-activedescendant` both read it as "position in the rendered
+    // list". Building the sections in a different order to the one they render
+    // in would desync the highlight from the keyboard.
+    let index = 0;
+    const sections = [];
+    if (filteredActions.length) {
+        sections.push({
+            heading: actionsHeading,
+            hideHeading: true,
+            rows: filteredActions.map((action) => ({
+                index: index++,
+                type: 'action',
+                name: action.label,
+                description: action.description,
+                hint: action.hint,
+                value: action.value,
+                action,
+            })),
+        });
+    }
+    // Outputs, then Context, then the command buckets.
+    //
+    // Above the commands because this is the one part of the palette that is
+    // about THIS session: the file the agent just wrote is the thing a user
+    // reaches for to say "now do X with it", and it must not sit below a
+    // scrolling list of skills. Below Actions because Actions are the fixed
+    // rows the palette's muscle memory is built on.
+    for (const origin of ['output', 'context']) {
+        const rows = filteredFiles.filter((f) => f.origin === origin).slice(0, fileCap);
+        if (!rows.length)
+            continue;
+        sections.push({
+            heading: origin === 'output' ? OUTPUTS_HEADING : CONTEXT_HEADING,
+            rows: rows.map((file) => ({
+                index: index++,
+                type: 'file',
+                name: file.name,
+                // The full path, so the detail pane answers "which file is this?"
+                // for a row whose name is a title or a repeated basename.
+                description: file.path,
+                value: file.folder || undefined,
+                file,
+            })),
+        });
+    }
+    for (const group of groupCommandsBySource(filteredCommands)) {
+        sections.push({
+            heading: group.heading,
+            rows: group.commands.map((command) => ({
+                index: index++,
+                type: 'command',
+                name: command.name || '',
+                description: command.description || '',
+                command,
+            })),
+        });
+    }
+    return sections;
+}

package/dist/session/composer/menus/slash-menu.d.ts

@@ -0,0 +1,44 @@
+import type { SlashRow, SlashSection } from './slash-items.js';
+/**
+ * The `/` palette.
+ *
+ * Two panes on desktop — a scrollable row list on the left, a detail pane on
+ * the right describing whatever is currently selected. The detail pane is
+ * driven entirely by `selectedIndex`, which the controller already owns
+ * (`MenuNavState`), so arrowing through the list updates the description with
+ * no extra state and no extra render path: the same prop that paints the
+ * highlight paints the detail.
+ *
+ * `onHover` folds the mouse into that same single index. Pointing at a skill,
+ * command, or action MAKES it the selection — the highlight moves, the detail
+ * pane describes what is under the cursor, and Enter takes what you are
+ * pointing at. Without it, hover was a second, weaker highlight that painted a
+ * row the pane refused to describe and Enter refused to run.
+ *
+ * The detail pane is hidden below `sm`. On a phone there is no room for two
+ * columns beside a keyboard, and the row list is the part you actually need —
+ * so the card degrades to the single column rather than shrinking both panes
+ * into uselessness.
+ *
+ * ## Docked, not floating
+ *
+ * `w-full` and `mb-2`, with no width of its own: this card is appended into a
+ * dock element that `composer.tsx` renders directly above the composer card
+ * (see `mount.ts`'s `mountDockedMenu` for the mechanism and the reasoning), so
+ * its width IS the composer's width and it sits in normal flow rather than
+ * over the page. `mb-2` lives here rather than on the dock so an empty dock —
+ * no match, or no menu open — contributes no gap at all: the margin cannot
+ * exist without a card to own it.
+ *
+ * `rounded-lg` (8px) is the cap `menu-shell.tsx` documents for app containers,
+ * and it is the same radius the `@` menu uses — the two palettes read as one
+ * system rather than two different popovers. It is deliberately NOT the
+ * composer card's `rounded-xl`: this card floats above the card, so matching
+ * it exactly made the seam between them read as a rendering glitch.
+ */
+export declare function SlashMenu({ sections, selectedIndex, onSelect, onHover, }: {
+    sections: SlashSection[];
+    selectedIndex: number;
+    onSelect: (row: SlashRow) => void;
+    onHover?: (row: SlashRow) => void;
+}): import("react").JSX.Element;

package/dist/session/composer/menus/slash-menu.js

@@ -0,0 +1,138 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Kbd } from '../../../primitives/kbd.js';
+import { getFileIcon } from '../../../files/project/components/file-icon.js';
+import { cn } from '../../../lib/utils.js';
+import { ArrowsClockwiseIcon, BrainIcon, PaperclipIcon, PlugsConnectedIcon, PuzzlePieceIcon, RobotIcon, SlidersHorizontalIcon, StackIcon, TerminalWindowIcon, } from '@phosphor-icons/react';
+import { ProgressRing } from '../../../primitives/progress-ring.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { ContextRing } from '../context-ring.js';
+import { ContextUsageCard } from '../token-progress.js';
+import { MenuCard, MenuRow, MenuSectionHeading } from './menu-shell.js';
+/**
+ * Per-row glyph. Commands are grouped by `Command.source` upstream
+ * (`slash-items.ts`'s `groupCommandsBySource`), but the row itself doesn't
+ * carry the source, so the heading it was filed under is what selects the
+ * icon — the same fact, read from the only place the view can see it.
+ */
+/**
+ * Returns the rendered element, not the component type.
+ *
+ * The obvious shape — `const Glyph = LOOKUP[id]; return <Glyph/>` — trips the
+ * React Compiler's `react-hooks/static-components` rule: it sees a capitalized
+ * binding assigned during render and cannot prove the lookup table is a frozen
+ * module constant, so it reports a component type that changes identity every
+ * render (which would remount the subtree if it were true). Returning elements
+ * from a switch keeps every element type statically resolvable, so the rule is
+ * satisfied by construction rather than suppressed.
+ */
+function SlashRowIcon({ row, heading, className, }) {
+    // Per-extension, not one generic file glyph: the palette's file rows are the
+    // same files the Outputs and Context cards draw, and those cards use this
+    // exact helper (`outputs-card.tsx`, `mention-menu.tsx`). A `.pdf` that looks
+    // like a `.pdf` in one surface and a blank page in another reads as two
+    // different files. `getFileIcon` returns an ELEMENT, which is also what
+    // keeps this switch free of the `static-components` problem below.
+    if (row.type === 'file' && row.file)
+        return getFileIcon(row.file.path, { className });
+    if (row.type === 'action' && row.action) {
+        switch (row.action.id) {
+            case 'switch-model':
+                return _jsx(ArrowsClockwiseIcon, { className: className });
+            case 'switch-agent':
+                return _jsx(RobotIcon, { className: className });
+            case 'set-reasoning-effort':
+                return _jsx(BrainIcon, { className: className });
+            case 'attach-file':
+                return _jsx(PaperclipIcon, { className: className });
+            // The stack glyph is the compaction mark everywhere else (the
+            // transcript's CompactionDivider and card) — the row must read as the
+            // same feature.
+            case 'compact-session':
+                return _jsx(StackIcon, { className: className });
+            // The SAME component as the underbar's context meter (`context-ring.tsx`),
+            // live reading and status tone included: the row opens the surface that
+            // ring opens, so it must BE that control, not a lookalike. The host fills
+            // `action.context` (composer.tsx); a host with no transcript omits it and
+            // gets the static muted fallback.
+            case 'show-context':
+                return row.action.context ? (_jsx(ContextRing, { percent: row.action.context.percent, tone: row.action.context.tone, className: className })) : (_jsx(ProgressRing, { value: 66, className: className }));
+            default:
+                return _jsx(SlidersHorizontalIcon, { className: className });
+        }
+    }
+    if (heading === 'Skills')
+        return _jsx(PuzzlePieceIcon, { className: className });
+    if (heading === 'MCP')
+        return _jsx(PlugsConnectedIcon, { className: className });
+    return _jsx(TerminalWindowIcon, { className: className });
+}
+/**
+ * The `/` palette.
+ *
+ * Two panes on desktop — a scrollable row list on the left, a detail pane on
+ * the right describing whatever is currently selected. The detail pane is
+ * driven entirely by `selectedIndex`, which the controller already owns
+ * (`MenuNavState`), so arrowing through the list updates the description with
+ * no extra state and no extra render path: the same prop that paints the
+ * highlight paints the detail.
+ *
+ * `onHover` folds the mouse into that same single index. Pointing at a skill,
+ * command, or action MAKES it the selection — the highlight moves, the detail
+ * pane describes what is under the cursor, and Enter takes what you are
+ * pointing at. Without it, hover was a second, weaker highlight that painted a
+ * row the pane refused to describe and Enter refused to run.
+ *
+ * The detail pane is hidden below `sm`. On a phone there is no room for two
+ * columns beside a keyboard, and the row list is the part you actually need —
+ * so the card degrades to the single column rather than shrinking both panes
+ * into uselessness.
+ *
+ * ## Docked, not floating
+ *
+ * `w-full` and `mb-2`, with no width of its own: this card is appended into a
+ * dock element that `composer.tsx` renders directly above the composer card
+ * (see `mount.ts`'s `mountDockedMenu` for the mechanism and the reasoning), so
+ * its width IS the composer's width and it sits in normal flow rather than
+ * over the page. `mb-2` lives here rather than on the dock so an empty dock —
+ * no match, or no menu open — contributes no gap at all: the margin cannot
+ * exist without a card to own it.
+ *
+ * `rounded-lg` (8px) is the cap `menu-shell.tsx` documents for app containers,
+ * and it is the same radius the `@` menu uses — the two palettes read as one
+ * system rather than two different popovers. It is deliberately NOT the
+ * composer card's `rounded-xl`: this card floats above the card, so matching
+ * it exactly made the seam between them read as a rendering glitch.
+ */
+export function SlashMenu({ sections, selectedIndex, onSelect, onHover, }) {
+    const t = useTranslations('sessionUi.composerMenus');
+    // A query that matches nothing keeps the card, with one dead row saying so.
+    // Returning `null` made the palette DISAPPEAR mid-word — the user could not
+    // tell "no match" from "the menu closed", and one backspace brought it back
+    // from nowhere.
+    if (!sections.length) {
+        return (_jsx(MenuCard, { className: cn('mb-2.5 w-full rounded-lg'), children: _jsx("p", { role: "status", className: "text-muted-foreground px-3 py-2.5 text-sm", children: t('noCommandMatch') }) }));
+    }
+    const rows = sections.flatMap((section) => section.rows.map((row) => ({ row, heading: section.heading })));
+    const active = rows.find(({ row }) => row.index === selectedIndex) ?? rows[0];
+    // Hovering "Show context" gets the SAME three-tier usage card the toolbar
+    // ring's hover opens (`token-progress.tsx`): the row is that control, so its
+    // preview must be that control's reading, not a prose paraphrase of it. The
+    // snapshot rides on the action (`context`, filled by the host); absent, the
+    // pane keeps the plain description.
+    const activeUsage = active && active.row.type === 'action' && active.row.action?.id === 'show-context'
+        ? active.row.action.context
+        : undefined;
+    return (_jsxs(MenuCard, { className: cn('mb-2.5 flex max-h-96 w-full overflow-hidden rounded-lg shadow-xs'), children: [_jsx("div", { role: "listbox", "aria-label": t('commandsAndActions'), "aria-activedescendant": `slash-row-${selectedIndex}`, 
+                // `-1`, matching `mention-menu.tsx`: focusable for AT, but never a tab
+                // stop. Keyboard interaction stays in the composer editor, which
+                // proxies arrow/Enter to this listbox — a real tab stop here trapped
+                // Tab between the palette and the composer.
+                tabIndex: -1, className: "min-w-0 flex-1 space-y-2 overflow-y-auto p-2", children: sections.map((section) => (_jsxs("div", { children: [!section.hideHeading && _jsx(MenuSectionHeading, { children: section.heading }), _jsx("div", { className: "space-y-0.5", children: section.rows.map((row) => (_jsxs(MenuRow, { id: `slash-row-${row.index}`, selected: row.index === selectedIndex, onSelect: () => onSelect(row), onHover: () => onHover?.(row), children: [_jsx(SlashRowIcon, { row: row, heading: section.heading, className: "text-muted-foreground size-4 shrink-0" }), _jsx("span", { className: "min-w-0 flex-1 truncate text-sm", children: row.name }), row.value && (_jsx("span", { className: "text-muted-foreground max-w-[8rem] shrink-0 truncate text-xs", children: row.value })), row.hint && _jsx(Kbd, { className: "shrink-0", children: row.hint })] }, `${row.type}-${row.name}-${row.index}`))) })] }, section.heading))) }), active && (_jsxs("div", { className: "border-border hidden w-[56%] max-w-[24rem] shrink-0 flex-col overflow-y-auto border-l p-4 sm:flex", children: [_jsxs("div", { className: "flex items-start gap-2.5", children: [_jsx(SlashRowIcon, { row: active.row, heading: active.heading, className: "text-muted-foreground mt-0.5 size-4 shrink-0" }), _jsx("p", { className: "text-foreground min-w-0 flex-1 text-sm font-medium break-words", children: active.row.name })] }), active.row.description && (_jsx("p", { className: "text-muted-foreground mt-2 text-sm leading-relaxed text-pretty", children: active.row.description })), activeUsage && (_jsx("div", { className: "mt-4 border-t pt-4", children: _jsx(ContextUsageCard, { breakdown: activeUsage.breakdown, limit: activeUsage.limit, ratio: activeUsage.ratio, tone: activeUsage.tone, modelName: activeUsage.modelName, interactive: false }) })), _jsxs("div", { className: "mt-auto flex items-center justify-end gap-2 pt-4", children: [_jsxs("span", { className: "text-muted-foreground flex items-center gap-1 text-xs", children: [_jsx(Kbd, { children: "\u21B5" }), " ", t('toUse')] }), _jsx("button", { type: "button", onMouseDown: (e) => {
+                                    e.preventDefault();
+                                    onSelect(active.row);
+                                }, className: cn('bg-primary text-primary-foreground rounded-full px-3.5 py-1.5 text-sm font-medium', 
+                                // Named properties, never `transition-all`: `scale` is driven
+                                // by `active:` and must stay interruptible on its own timeline.
+                                'duration-normal cursor-pointer transition-[background-color,scale] active:scale-[0.96]'), children: t('use') })] })] }))] }));
+}

package/dist/session/composer/pasted-text.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A paste's full text, in the side panel's detail view or `PastedTextModal`.
+ * Its one action, Copy, sits in the header (`PastedTextCopy`): the text is
+ * already in the chat, so there is nothing to download or add.
+ */
+export declare function PastedTextBody({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+export declare function PastedTextCopy({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+/** Word and character counts for the header. Characters are what the user sees: graphemes, else code points. */
+export declare function pastedTextCounts(text: string): {
+    words: number;
+    chars: number;
+};
+/** "72 words · 449 characters", the header meta of the panel and the modal. */
+export declare function PastedTextMeta({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+/** The side panel's paste view, as a modal, for hosts with no side panel (project home). */
+export declare function PastedTextModal({ text, onClose }: {
+    text: string | null;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/session/composer/pasted-text.js

@@ -0,0 +1,55 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CopyButton } from '../../markdown/copy-button.js';
+import { ButtonGroup } from '../../primitives/button-group.js';
+import { InlineMeta } from '../../primitives/inline-meta.js';
+import { Modal, ModalContent, ModalDescription, ModalHeader, ModalTitle, } from '../../primitives/modal.js';
+import { useTranslations } from '../../i18n/index.js';
+import { CloseButton } from '../../files/viewer/viewer-chrome.js';
+/**
+ * A paste's full text, in the side panel's detail view or `PastedTextModal`.
+ * Its one action, Copy, sits in the header (`PastedTextCopy`): the text is
+ * already in the chat, so there is nothing to download or add.
+ */
+export function PastedTextBody({ text }) {
+    return (_jsx("pre", { className: "bg-popover text-foreground rounded-md border px-4 py-3 font-mono text-xs break-words whitespace-pre-wrap select-text", children: text }));
+}
+export function PastedTextCopy({ text }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    // The toolbar `ButtonGroup`'s look: `size-7` on the `secondary` fill, as `CloseButton`.
+    return (_jsx(CopyButton, { code: text, size: "md", className: "bg-secondary hover:bg-secondary/90 shrink-0", label: t.raw('texte21f935f11d7') }));
+}
+/** Word and character counts for the header. Characters are what the user sees: graphemes, else code points. */
+export function pastedTextCounts(text) {
+    const words = text.trim() ? text.trim().split(/\s+/).length : 0;
+    let chars = 0;
+    if (typeof Intl !== 'undefined' && 'Segmenter' in Intl) {
+        for (const _segment of new Intl.Segmenter().segment(text))
+            chars++;
+    }
+    else
+        chars = Array.from(text).length;
+    return { words, chars };
+}
+/** "72 words · 449 characters", the header meta of the panel and the modal. */
+export function PastedTextMeta({ text }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    const { words, chars } = pastedTextCounts(text);
+    return (_jsxs(InlineMeta, { children: [_jsx("span", { children: t('text23d0bb29fca0', { count: words }) }), _jsx("span", { children: t('text426699d5a8c0', { count: chars }) })] }));
+}
+/** The side panel's paste view, as a modal, for hosts with no side panel (project home). */
+export function PastedTextModal({ text, onClose }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    return (_jsx(Modal, { open: text !== null, onOpenChange: (open) => !open && onClose(), children: _jsxs(ModalContent
+        // Only the body scrolls: the header, Copy and Close (absolute in the
+        // content box) stay in view on a long paste.
+        , { 
+            // Only the body scrolls: the header, Copy and Close (absolute in the
+            // content box) stay in view on a long paste.
+            className: "flex flex-col overflow-hidden lg:h-auto lg:max-h-[85svh] lg:max-w-2xl", 
+            // Copy and Close as one `ButtonGroup`, as in the side panel's toolbar.
+            showCloseButton: false, closeButtonChildren: _jsxs(ButtonGroup, { children: [text !== null && _jsx(PastedTextCopy, { text: text }), _jsx(CloseButton, { onClose: onClose })] }), 
+            // Opening focus would land on Copy and open its tooltip, so the first
+            // Esc only closed the tooltip. Keep focus off the controls: one Esc closes.
+            onOpenAutoFocus: (event) => event.preventDefault(), children: [_jsxs(ModalHeader, { className: "pr-20", children: [_jsx(ModalTitle, { children: t.raw('text39cfc32bd12c') }), _jsx(ModalDescription, { asChild: true, children: _jsx("div", { children: text !== null && _jsx(PastedTextMeta, { text: text }) }) })] }), _jsx("div", { className: "min-h-0 flex-1 overflow-y-auto px-5 pb-5", children: text !== null && _jsx(PastedTextBody, { text: text }) })] }) }));
+}

package/dist/session/composer/queue-projection.d.ts

@@ -0,0 +1,102 @@
+import type { QueuedDraft } from './stores/queued-draft-store.js';
+import { type SessionPrompt, type SessionPromptDelivery, type SessionPromptSteerFallback, type SessionPromptViewer } from '@kortix/sdk';
+/**
+ * What the queued list above the composer (`composer/queued-prompt-list.tsx`)
+ * renders, from the ONE thing that holds a pending message.
+ *
+ * The server inbox (`GET .../prompts`) is the queue: durable, shared across
+ * tabs and devices, ordered and admitted by the control plane. Composer entries
+ * stay here until admitted. Transcript entries are drawn in the conversation.
+ *
+ * `drafts` are this tab's own queued sends (`queued-draft-store.ts`). They add
+ * the text as typed, the original files, and a row for the upload window before
+ * the inbox has one. They never add a row the inbox has already delivered.
+ */
+/**
+ * Is this row the session's FIRST prompt? `startSessionWithPrompt` mints
+ * `start_…`; the API's `create.pending_prompt` mints `pending:<session>`
+ * (`apps/api/.../pending-prompt.ts`). That prompt is the turn about to run, and
+ * the transcript draws it (`OptimisticTurn`, synthetic turns) — never the list.
+ */
+export declare function isFirstPromptRow(prompt: Pick<SessionPrompt, 'client_message_id'>): boolean;
+/**
+ * - `sending`: this tab's send, not yet confirmed by the server. No server id,
+ *   so nothing can be done to it yet.
+ * - `queued`: waiting for its turn (held rows included — see `heldCount`).
+ * - `delivering`: handed to the runtime; its turn is starting. The server
+ *   refuses removal.
+ * - `failed`: delivery gave up; retry or remove.
+ */
+export type QueueRowState = 'sending' | 'queued' | 'delivering' | 'failed';
+export interface QueueRow {
+    /** The inbox `prompt_id`, or `draft:<clientMessageId>` before the POST. */
+    id: string;
+    clientMessageId: string;
+    text: string;
+    attachmentCount: number;
+    state: QueueRowState;
+    lastError?: string;
+    /** The server can still remove this prompt, and this viewer may. */
+    removable: boolean;
+    /** Delivery gave up and this viewer may send it again (its author). */
+    retryable: boolean;
+    /** Another member sent it: it runs as them, so only they edit or send it. */
+    fromAnotherMember?: true;
+    /** The running turn reads this prompt at its next step (`delivery: 'steer'`). */
+    steer?: true;
+    /** Why a steer prompt waits for the turn to end instead. */
+    steerFallback?: SessionPromptSteerFallback;
+    /** "Stop and send" can turn it into Quick Queue: it is still waiting and
+     *  not yet on the wire. */
+    interruptible: boolean;
+    /** A `/` command held in this tab until the session can run it
+     *  (`held-commands.ts`). Not an inbox row. */
+    command?: true;
+    /** Up (or the pencil) opens it in the composer for an in-place edit. */
+    takeBackEligible: boolean;
+    /** The prompt's whole text as the server holds it: quotes, file and
+     *  mention markup included. */
+    rawText: string;
+    /** The words the composer edits — one verbatim run of `rawText`, so an edit
+     *  swaps exactly them and every quote or reference around them survives.
+     *  `null` when the visible words are not one run, so no edit is offered. */
+    editText: string | null;
+}
+export interface QueueProjection {
+    /** In delivery order: the server's rows first, then this tab's unsent drafts. */
+    rows: QueueRow[];
+    /** Rows the Stop hold is pausing — counted even when the row is on screen in
+     *  the transcript, so Resume is reachable whenever the server holds anything. */
+    heldCount: number;
+}
+/** A prompt's visible words: the transport blocks the send path appends
+ *  (pastes, reply context, upload refs, mention refs) stripped back out. */
+export declare function cleanPromptText(text: string): {
+    text: string;
+    fileCount: number;
+    /** Present when the prompt carries `<pasted_content>` blocks. */
+    pasteCount?: number;
+};
+export declare function projectQueueRows(input: {
+    prompts: readonly SessionPrompt[];
+    /** Every message id the transcript is showing. Optional for callers with no
+     *  transcript (tests). */
+    transcriptMessageIds?: ReadonlySet<string>;
+    drafts?: readonly QueuedDraft[];
+    /** Who is looking. A prompt runs as its author, so edit, Stop and send and
+     *  retry are the author's only (`sessionPromptActions`). Omitted: every row
+     *  reads as the viewer's own. */
+    viewer?: SessionPromptViewer;
+}): QueueProjection;
+/**
+ * How a composer send reaches the session (D9.1).
+ *
+ * - Enter while a turn runs: `steer`. The running turn reads it at its next
+ *   step. It waits in the list above the composer until the transcript has it.
+ * - Cmd/Ctrl+Enter (`composer`): `queue` (Queue List).
+ * - Enter while idle: unchanged. It starts a turn and paints in the transcript.
+ */
+export declare function composerSendDelivery(placement: 'transcript' | 'composer', busy: boolean): {
+    placement: 'transcript' | 'composer';
+    delivery?: SessionPromptDelivery;
+};