@adecore/agents-react 0.0.1 → 0.17.0-beta.2

package/dist/chat/ui/code-lines.d.ts

@@ -0,0 +1,18 @@
+export interface CodeToken {
+    content: string;
+    color?: string;
+    fontStyle?: number;
+}
+export type Tokenize<State> = (code: string, state: State | undefined) => {
+    lines: CodeToken[][];
+    state: State | undefined;
+};
+export declare class IncrementalLines<State> {
+    private readonly tokenize;
+    private source;
+    private lines;
+    private state;
+    constructor(tokenize: Tokenize<State>);
+    update(code: string, complete: boolean): CodeToken[][];
+    private reset;
+}

package/dist/chat/ui/code-lines.js

@@ -0,0 +1,46 @@
+/*
+ * The lines of a code block that grows at the end. A line that ended keeps the tokens it got, and
+ * the grammar state after it is where the next line starts, so a delta tokenizes the lines that are
+ * new plus the one still being written, however long the block already is. The last line is always
+ * tokenized again, since the next delta may turn it into anything (the start of a comment, a string).
+ */
+export class IncrementalLines {
+    tokenize;
+    // The text of the lines that are kept: empty, or ending in a newline while the block grows.
+    source = '';
+    lines = [];
+    state = undefined;
+    constructor(tokenize) {
+        this.tokenize = tokenize;
+    }
+    /* The tokens of every line of `code`; `complete` says nothing more arrives, so the last line is kept too. */
+    update(code, complete) {
+        // A carriage return splits lines in ways a cut at newlines does not see, so that code starts over every time.
+        if (code.includes('\r')) {
+            this.reset();
+            return this.tokenize(code, undefined).lines;
+        }
+        const end = complete ? code.length : code.lastIndexOf('\n') + 1;
+        const stable = code.slice(0, end);
+        const continues = (this.source === '' || this.source.endsWith('\n')) && stable.startsWith(this.source);
+        if (!continues) {
+            this.reset();
+        }
+        const added = stable.slice(this.source.length);
+        if (added !== '') {
+            const result = this.tokenize(added.endsWith('\n') ? added.slice(0, -1) : added, this.state);
+            this.lines = [...this.lines, ...result.lines];
+            this.state = result.state;
+            this.source = stable;
+        }
+        if (complete) {
+            return this.lines;
+        }
+        return [...this.lines, ...this.tokenize(code.slice(end), this.state).lines];
+    }
+    reset() {
+        this.source = '';
+        this.lines = [];
+        this.state = undefined;
+    }
+}

package/dist/chat/ui/code-streaming.d.ts

@@ -0,0 +1 @@
+export declare const CodeStreamingContext: import("react").Context<boolean>;

package/dist/chat/ui/code-streaming.js

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+/* Whether the code blocks below are still being written, which a reply says for the fence that has not closed. */
+export const CodeStreamingContext = createContext(false);

package/dist/chat/ui/code-theme.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeRegistration } from 'shiki';
+export declare function useCodeTheme(): string;
+export declare function shikiThemeOf(id: string): string | ThemeRegistration;

package/dist/chat/ui/code-theme.js

@@ -0,0 +1,12 @@
+import { chatHost } from '../../host.js';
+/* The Shiki theme code is drawn in under the app's current light or dark. */
+export function useCodeTheme() {
+    const { code } = chatHost();
+    const mode = code.useMode();
+    const themes = code.useThemes();
+    return mode === 'dark' ? themes.dark : themes.light;
+}
+/* What to hand Shiki for a theme id: a theme the app ships itself, or the id of a bundled one for Shiki to load. */
+export function shikiThemeOf(id) {
+    return chatHost().code.custom.find((theme) => theme.name === id) ?? id;
+}

package/dist/chat/ui/composer/chips.d.ts

@@ -0,0 +1,6 @@
+import { type Extension } from '@codemirror/state';
+export interface ChipChoices {
+    mentions: string[];
+    skills: string[];
+}
+export declare function chipDecorations(value: ChipChoices): Extension;

package/dist/chat/ui/composer/chips.js

@@ -0,0 +1,31 @@
+import { syntaxTree } from '@codemirror/language';
+import { Facet, RangeSetBuilder, StateField } from '@codemirror/state';
+import { Decoration, EditorView } from '@codemirror/view';
+import { chipRanges } from '../../mentions.js';
+import { CHIP_IN_EDITOR, MENTION_TONE, SKILL_TONE } from '../chips.js';
+import { codeRanges } from './editor.js';
+const NO_CHOICES = { mentions: [], skills: [] };
+const choices = Facet.define({ combine: (values) => values[0] ?? NO_CHOICES });
+const mentionMark = Decoration.mark({ class: `${MENTION_TONE} ${CHIP_IN_EDITOR}` });
+const skillMark = Decoration.mark({ class: `${SKILL_TONE} ${CHIP_IN_EDITOR}` });
+function chipMarks(state) {
+    const { mentions, skills } = state.facet(choices);
+    const builder = new RangeSetBuilder();
+    // `@a.ts` in backticks is code, not a mention.
+    for (const range of chipRanges(state.doc.toString(), mentions, skills, codeRanges(state))) {
+        builder.add(range.from, range.to, range.kind === 'skill' ? skillMark : mentionMark);
+    }
+    return builder.finish();
+}
+const chipField = StateField.define({
+    create: chipMarks,
+    // The parser finishes a long text after the edit that asked for it, and a code span it finds then unmakes a chip.
+    update: (marks, tr) => tr.docChanged || tr.startState.facet(choices) !== tr.state.facet(choices) || syntaxTree(tr.startState) !== syntaxTree(tr.state)
+        ? chipMarks(tr.state)
+        : marks,
+    provide: (field) => EditorView.decorations.from(field)
+});
+/* Draws the chosen `@path` and `$name` tokens as chips; a new `ChipChoices` object is what redraws them. */
+export function chipDecorations(value) {
+    return [choices.of(value), chipField];
+}

package/dist/chat/ui/composer/editor.d.ts

@@ -0,0 +1,11 @@
+import { Language } from '@codemirror/language';
+import { type EditorState, type Extension } from '@codemirror/state';
+export declare const externalChange: import("@codemirror/state").AnnotationType<boolean>;
+export declare const markdownLanguage: Language;
+export interface CodeRange {
+    from: number;
+    to: number;
+    kind: 'inline' | 'fence';
+}
+export declare function codeRanges(state: EditorState, from?: number, to?: number): CodeRange[];
+export declare function composerEditorExtensions(): Extension;

package/dist/chat/ui/composer/editor.js

@@ -0,0 +1,98 @@
+import { history, historyKeymap, standardKeymap } from '@codemirror/commands';
+import { Language, defineLanguageFacet, indentUnit, syntaxHighlighting, syntaxTree } from '@codemirror/language';
+import { Annotation } from '@codemirror/state';
+import { Decoration, EditorView, ViewPlugin, keymap } from '@codemirror/view';
+import { tagHighlighter, tags } from '@lezer/highlight';
+import { Strikethrough, Table, parser } from '@lezer/markdown';
+/* Marks a transaction that brings the editor in line with a value set from outside, so it is not reported back. */
+export const externalChange = Annotation.define();
+/*
+ * The markdown grammar in a Language of our own. `@codemirror/lang-markdown` builds the same thing
+ * but creates the HTML language and autocomplete at module level, which tree shaking cannot drop.
+ */
+export const markdownLanguage = new Language(defineLanguageFacet(), parser.configure([Strikethrough, Table]), [], 'markdown');
+/* Classes rather than generated styles, so the look lives in `styles.css` on the theme's tokens. */
+const markdownClasses = tagHighlighter([
+    { tag: tags.strong, class: 'cm-md-strong' },
+    { tag: tags.emphasis, class: 'cm-md-emphasis' },
+    { tag: tags.strikethrough, class: 'cm-md-strike' },
+    { tag: tags.heading, class: 'cm-md-heading' },
+    { tag: [tags.link, tags.url], class: 'cm-md-link' },
+    { tag: tags.processingInstruction, class: 'cm-md-mark' }
+]);
+/* The code spans and fenced blocks between `from` and `to`, as far as the parser has got. */
+export function codeRanges(state, from = 0, to = state.doc.length) {
+    const found = [];
+    syntaxTree(state).iterate({
+        from,
+        to,
+        enter: (node) => {
+            if (node.name === 'InlineCode' || node.name === 'FencedCode') {
+                found.push({ from: node.from, to: node.to, kind: node.name === 'InlineCode' ? 'inline' : 'fence' });
+                return false;
+            }
+            return undefined;
+        }
+    });
+    return found;
+}
+const inlineCodeMark = Decoration.mark({ class: 'cm-md-code' });
+function fenceLine(first, last) {
+    return Decoration.line({ class: ['cm-md-fence', first ? 'cm-md-fence-start' : '', last ? 'cm-md-fence-end' : ''].join(' ').trim() });
+}
+/*
+ * Code is decorated from the tree rather than highlighted per token: the highlighter styles the
+ * backticks apart from what they wrap, and a block's background belongs to its whole lines.
+ */
+function codeDecorations(view) {
+    const { state } = view;
+    const decorations = [];
+    const fenceLines = new Set();
+    for (const visible of view.visibleRanges) {
+        for (const range of codeRanges(state, visible.from, visible.to)) {
+            if (range.kind === 'inline') {
+                decorations.push(inlineCodeMark.range(range.from, range.to));
+                continue;
+            }
+            const first = state.doc.lineAt(range.from).number;
+            const last = state.doc.lineAt(range.to).number;
+            const start = state.doc.lineAt(Math.max(range.from, visible.from)).number;
+            const end = state.doc.lineAt(Math.min(range.to, visible.to)).number;
+            for (let number = start; number <= end; number++) {
+                if (!fenceLines.has(number)) {
+                    fenceLines.add(number);
+                    decorations.push(fenceLine(number === first, number === last).range(state.doc.line(number).from));
+                }
+            }
+        }
+    }
+    return Decoration.set(decorations, true);
+}
+const codeDecorationPlugin = ViewPlugin.fromClass(class {
+    decorations;
+    constructor(view) {
+        this.decorations = codeDecorations(view);
+    }
+    update(update) {
+        if (update.docChanged || update.viewportChanged || syntaxTree(update.startState) !== syntaxTree(update.state)) {
+            this.decorations = codeDecorations(update.view);
+        }
+    }
+}, { decorations: (plugin) => plugin.decorations });
+/*
+ * What every composer editor carries. The standard keymap rather than the default one: the default
+ * adds code editor commands (move a line, indent, select the syntax parent) on keys a prompt box
+ * has no business taking.
+ */
+export function composerEditorExtensions() {
+    return [
+        history(),
+        keymap.of([...standardKeymap, ...historyKeymap]),
+        EditorView.lineWrapping,
+        // What Tab and Shift+Tab in a fence add and take away, so a selection indents in the same steps as a caret.
+        indentUnit.of('    '),
+        markdownLanguage,
+        syntaxHighlighting(markdownClasses),
+        codeDecorationPlugin
+    ];
+}

package/dist/chat/ui/composer/insert.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState, TransactionSpec } from '@codemirror/state';
+export declare function insertAtSelection(state: EditorState, text: string): TransactionSpec;

package/dist/chat/ui/composer/insert.js

@@ -0,0 +1,19 @@
+function isSpace(text) {
+    return /^\s/.test(text);
+}
+/*
+ * Text an app puts in the draft, over the selection, as if it were typed there. A space keeps it apart
+ * from a word it would touch, and one after it at the end of the text lets the person type on.
+ */
+export function insertAtSelection(state, text) {
+    if (text === '') {
+        return {};
+    }
+    const { from, to } = state.selection.main;
+    const before = state.doc.sliceString(Math.max(0, from - 1), from);
+    const after = state.doc.sliceString(to, to + 1);
+    const lead = before !== '' && !isSpace(before) && !isSpace(text) ? ' ' : '';
+    const trail = (after === '' || !isSpace(after)) && !/\s$/.test(text) ? ' ' : '';
+    const insert = `${lead}${text}${trail}`;
+    return { changes: { from, to, insert }, selection: { anchor: from + insert.length }, scrollIntoView: true, userEvent: 'input' };
+}

package/dist/chat/ui/composer/keys.d.ts

@@ -0,0 +1,30 @@
+import type { Tree } from '@lezer/common';
+export type EnterAction = 'send' | 'newline' | 'continue-list' | 'leave-list';
+export interface EnterKeys {
+    shift: boolean;
+    mod: boolean;
+}
+export interface ListItem {
+    prefix: string;
+    next: string;
+    empty: boolean;
+}
+export interface EnterContext {
+    inOpenFence: boolean;
+    list: ListItem | null;
+    column: number;
+}
+export declare function listItemAt(line: string): ListItem | null;
+export declare function enterAction(keys: EnterKeys, { inOpenFence, list, column }: EnterContext): EnterAction;
+export declare function inOpenFence(tree: Tree, pos: number): boolean;
+export declare function inFenceBody(tree: Tree, text: string, pos: number): boolean;
+export declare function tabSpaces(column: number): string;
+export declare function inCode(tree: Tree, text: string, pos: number): boolean;
+export interface RecallContext {
+    key: string;
+    text: string;
+    from: number;
+    to: number;
+    recalled: boolean;
+}
+export declare function recallDirection({ key, text, from, to, recalled }: RecallContext): -1 | 1 | null;

package/dist/chat/ui/composer/keys.js

@@ -0,0 +1,100 @@
+const LIST_ITEM = /^([ \t]*)(?:([-*+])|(\d{1,9})([.)]))([ \t]+)(\[[ xX]\](?:[ \t]+|$))?/;
+/* The list item a line starts, if it starts one. */
+export function listItemAt(line) {
+    const match = LIST_ITEM.exec(line);
+    if (match === null) {
+        return null;
+    }
+    const [prefix, indent, bullet, number, delimiter, space, task] = match;
+    const marker = bullet ?? `${Number(number) + 1}${delimiter}`;
+    return { prefix, next: `${indent}${marker}${space}${task ? '[ ] ' : ''}`, empty: line.slice(prefix.length).trim() === '' };
+}
+/*
+ * Enter sends, except where whoever types is still writing: inside a fence nobody has closed yet
+ * it adds a line, and in a list it starts the next item, or leaves the list from an empty one, so
+ * a second Enter breaks out. Shift adds a plain line and Mod sends from anywhere.
+ */
+export function enterAction(keys, { inOpenFence, list, column }) {
+    if (keys.mod) {
+        return 'send';
+    }
+    if (keys.shift || inOpenFence) {
+        return 'newline';
+    }
+    if (list === null) {
+        return 'send';
+    }
+    // A caret in front of the marker moves the item down rather than splitting its marker.
+    if (column < list.prefix.length) {
+        return 'newline';
+    }
+    return list.empty ? 'leave-list' : 'continue-list';
+}
+/* Whether `pos` sits inside a fenced code block that has an opening fence and no closing one yet. */
+export function inOpenFence(tree, pos) {
+    for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
+        if (node.name === 'FencedCode') {
+            return pos > node.from && node.getChildren('CodeMark').length < 2;
+        }
+    }
+    return false;
+}
+/* Whether `pos` sits in the body of a fenced code block, open or closed: below its opening line and before its end. */
+export function inFenceBody(tree, text, pos) {
+    for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
+        if (node.name === 'FencedCode') {
+            const openingEnd = text.indexOf('\n', node.from);
+            return openingEnd !== -1 && pos > openingEnd && (pos < node.to || node.getChildren('CodeMark').length < 2);
+        }
+    }
+    return false;
+}
+/* The spaces Tab inserts at `column`, up to the next stop of four, the way a code editor lines up. */
+export function tabSpaces(column) {
+    return ' '.repeat(4 - (column % 4));
+}
+const INLINE_BLOCK = /^(Paragraph|ATXHeading\d|SetextHeading\d)$/;
+/*
+ * Whether `pos` sits inside code: a fence, open or closed, or a code span. The parser only calls a
+ * span code once it is closed, so a backtick nobody has closed yet earlier in the same paragraph
+ * counts as well: whoever types after it is writing code.
+ */
+export function inCode(tree, text, pos) {
+    let blockFrom = null;
+    for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
+        if (node.name === 'FencedCode') {
+            return pos > node.from && (pos < node.to || node.getChildren('CodeMark').length < 2);
+        }
+        if (node.name === 'InlineCode' && pos > node.from && pos < node.to) {
+            return true;
+        }
+        if (blockFrom === null && INLINE_BLOCK.test(node.name)) {
+            blockFrom = node.from;
+        }
+    }
+    let from = blockFrom ?? text.lastIndexOf('\n', pos - 1) + 1;
+    tree.iterate({
+        from,
+        to: pos,
+        enter: (node) => {
+            if (node.name === 'InlineCode' && node.to <= pos) {
+                from = Math.max(from, node.to);
+            }
+        }
+    });
+    return /(^|[^\\])`/.test(text.slice(from, pos));
+}
+/*
+ * Which way the arrow walks through earlier prompts, or null when the arrow just moves the caret.
+ * Only an empty box or an unedited recall walks, so an arrow in a prompt being written never
+ * throws it away.
+ */
+export function recallDirection({ key, text, from, to, recalled }) {
+    if (key === 'ArrowUp' && (text === '' || (recalled && from === 0))) {
+        return -1;
+    }
+    if (key === 'ArrowDown' && recalled && to === text.length) {
+        return 1;
+    }
+    return null;
+}

package/dist/chat/ui/diff-theme.d.ts

@@ -0,0 +1,2 @@
+import { type ThemesType } from '@pierre/diffs';
+export declare function useDiffTheme(): ThemesType;

package/dist/chat/ui/diff-theme.js

@@ -0,0 +1,20 @@
+import { useMemo } from 'react';
+import { registerCustomTheme } from '@pierre/diffs';
+import { chatHost } from '../../host.js';
+let registered = false;
+/* The library resolves Shiki's bundled themes by id on its own; the app's own it only knows by registration, done once the host is set. */
+function registerThemes() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    for (const theme of chatHost().code.custom) {
+        registerCustomTheme(theme.name, () => Promise.resolve(theme));
+    }
+}
+/* The code themes a diff is drawn in, the same pair a chat's code blocks use. */
+export function useDiffTheme() {
+    registerThemes();
+    const { light, dark } = chatHost().code.useThemes();
+    return useMemo(() => ({ light, dark }), [light, dark]);
+}

package/dist/chat/ui/file-links.d.ts

@@ -0,0 +1,5 @@
+import { type FileRef } from '../../host.js';
+export declare const FileLinkContext: import("react").Context<string | null>;
+export declare function useFileLinkCwd(): string | null;
+export declare function useFileLinkTarget(text: string): FileRef | null;
+export declare function openFileLink(cwd: string | null, ref: FileRef): void;

package/dist/chat/ui/file-links.js

@@ -0,0 +1,20 @@
+import { createContext, useContext, useMemo } from 'react';
+import { chatHost } from '../../host.js';
+/*
+ * The folder a relative reference in rendered text counts from: a chat's own cwd, which is a
+ * worktree as often as it is the project, or the folder of the file an app is drawing. Null where
+ * nobody said, and there only an absolute path is a link.
+ */
+export const FileLinkContext = createContext(null);
+export function useFileLinkCwd() {
+    return useContext(FileLinkContext);
+}
+/* The reference a piece of text names, only where this spot on screen could open it. */
+export function useFileLinkTarget(text) {
+    const cwd = useFileLinkCwd();
+    return useMemo(() => chatHost().fileLinks?.target(text, cwd) ?? null, [text, cwd]);
+}
+/* A reference followed, the way the app opens a file or a folder. */
+export function openFileLink(cwd, ref) {
+    chatHost().fileLinks?.open(cwd, ref);
+}

package/dist/chat/ui/find-reveal.d.ts

@@ -0,0 +1,7 @@
+export type ChatFindField = 'summary' | 'text' | 'output';
+export interface FindReveal {
+    itemId: string;
+    field: ChatFindField;
+}
+export declare const FindRevealContext: import("react").Context<FindReveal | null>;
+export declare function useOpenForFind(itemId: string, field: ChatFindField, setOpen: (open: boolean) => void): void;

package/dist/chat/ui/find-reveal.js

@@ -0,0 +1,13 @@
+import { createContext, useContext, useEffect } from 'react';
+/* The hit the find bar is on, so the row that folds it away can open. */
+export const FindRevealContext = createContext(null);
+/* Opens a fold of this item while the find bar is on a hit inside it; it stays open once the bar moves on, as if a person opened it. */
+export function useOpenForFind(itemId, field, setOpen) {
+    const reveal = useContext(FindRevealContext);
+    const wanted = reveal !== null && reveal.itemId === itemId && reveal.field === field;
+    useEffect(() => {
+        if (wanted) {
+            setOpen(true);
+        }
+    }, [wanted, reveal, setOpen]);
+}

package/dist/chat/ui/full-diff.d.ts

@@ -0,0 +1,6 @@
+import { type FileDiffMetadata } from '@pierre/diffs';
+export interface DiffContents {
+    readonly old: string;
+    readonly new: string;
+}
+export declare function fullFileDiff(patch: string, name: string, contents: DiffContents): FileDiffMetadata | null;

package/dist/chat/ui/full-diff.js

@@ -0,0 +1,19 @@
+import { processFile } from '@pierre/diffs';
+/*
+ * A patch laid over the two whole texts it was made between, which is what lets a reader unfold
+ * the lines between its hunks. The hunks stay the patch's own, so a patch made without whitespace
+ * keeps its counts. Null when there is no hunk to lay over them, and the patch alone is drawn.
+ */
+export function fullFileDiff(patch, name, contents) {
+    try {
+        const parsed = processFile(patch, {
+            oldFile: { name, contents: contents.old },
+            newFile: { name, contents: contents.new },
+            throwOnError: true
+        });
+        return parsed === undefined || parsed.isPartial || parsed.hunks.length === 0 ? null : parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/chat/ui/icons.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export declare const DOCK_ICON_SIZE = 14;
+export declare const ROW_GUTTER = "grid h-5 w-4 shrink-0 place-items-center";
+export declare function toolIcon(name: string, size?: number): ReactNode;

package/dist/chat/ui/icons.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Hammer, Wrench } from 'lucide-react';
+import { toolEntry } from '../logic/tool-catalog.js';
+import { Icon } from '@adecore/ui';
+const SIZE = 12;
+/* A pending dock draws its mark a step up from the lines of a transcript, at the size a sidebar
+   row uses, because it is a thing to answer rather than a thing to read past. */
+export const DOCK_ICON_SIZE = 14;
+/* The gutter every row in the thread opens with: 16 wide, on the line box of its first row of text,
+   so the mark of a tool call, a note and a fold all sit in one column and their labels start at the
+   same x. The same box the menu rows and the toasts use. */
+export const ROW_GUTTER = 'grid h-5 w-4 shrink-0 place-items-center';
+/* The icon that says what a tool call is about; unknown tools get the wrench. */
+export function toolIcon(name, size = SIZE) {
+    const known = toolEntry(name);
+    if (known !== undefined) {
+        return _jsx(Icon, { icon: known.icon, size: size });
+    }
+    return name.startsWith('mcp__') ? _jsx(Icon, { icon: Hammer, size: size }) : _jsx(Icon, { icon: Wrench, size: size });
+}

package/dist/chat/ui/markdown-blocks.d.ts

@@ -0,0 +1,6 @@
+export interface MarkdownBlock {
+    text: string;
+    openFence: boolean;
+}
+export declare function splitMarkdownBlocks(text: string): MarkdownBlock[];
+export declare function settledBlocksText(text: string): string;

package/dist/chat/ui/markdown-blocks.js

@@ -0,0 +1,103 @@
+const FENCE = /^([ \t]*)(`{3,}|~{3,})(.*)$/;
+// Spaces and tabs only: a line that holds a no-break space is text to markdown, not a blank line.
+const BLANK = /^[ \t]*$/;
+// A line that continues what stood before the blank line: an indented paragraph of a list item, or
+// the next item of a loose list. Splitting there would change what the markdown means.
+const CONTINUES = /^([ \t]|[-*+][ \t]|\d+[.)][ \t])/;
+// A reference or footnote definition may be used anywhere in the text, so a block cannot stand alone.
+const DEFINITION = /^ {0,3}\[[^\]]+\]:/m;
+// How much deeper than its opening a closing fence may sit; deeper than that it is a line of code.
+const CLOSING_INDENT = 3;
+// A section title: an ATX heading, or a line of only bold text, which models write as a heading too.
+const HEADING = /^ {0,3}#{1,6}(?:[ \t]|$)/;
+const BOLD_LINE = /^ {0,3}\*\*(?:[^*]|\*(?!\*))+\*\*:?[ \t]*$/;
+/*
+ * A reply cut into blocks at blank lines outside a code fence, so each block parses on its own and
+ * only the one still growing is parsed again. Joined back together the blocks are the text.
+ */
+export function splitMarkdownBlocks(text) {
+    if (DEFINITION.test(text)) {
+        return [{ text, openFence: isFenceOpenAtEnd(text) }];
+    }
+    const lines = text.split('\n');
+    const blocks = [];
+    let start = 0;
+    let offset = 0;
+    let fence = null;
+    let afterBlank = false;
+    lines.forEach((line, index) => {
+        if (fence === null && afterBlank && !BLANK.test(line) && !CONTINUES.test(line)) {
+            blocks.push({ text: text.slice(start, offset), openFence: false });
+            start = offset;
+        }
+        fence = nextFence(fence, line);
+        afterBlank = fence === null && BLANK.test(line) && index > 0;
+        offset += line.length + 1;
+    });
+    blocks.push({ text: text.slice(start), openFence: fence !== null });
+    return blocks;
+}
+/*
+ * The blocks of a reply still being written that will not change any more: every block but the last.
+ * A block is only known to be closed once the line after its blank line starts, since that line may
+ * still turn out to continue it (a list item, an indented paragraph). A section title waits for the
+ * block under it, so it never sits alone above a block that is still streaming.
+ */
+export function settledBlocksText(text) {
+    return withoutTrailingTitles(splitMarkdownBlocks(text)
+        .slice(0, -1)
+        .map((block) => block.text)
+        .join(''));
+}
+function withoutTrailingTitles(text) {
+    const lines = text.split('\n');
+    let end = lines.length;
+    for (let index = lines.length - 1; index >= 0; index--) {
+        const line = lines[index];
+        if (BLANK.test(line)) {
+            continue;
+        }
+        // A bold line right under a line of text continues that paragraph.
+        const title = HEADING.test(line) || (BOLD_LINE.test(line) && (index === 0 || BLANK.test(lines[index - 1])));
+        if (!title) {
+            break;
+        }
+        end = index;
+    }
+    if (end === lines.length) {
+        return text;
+    }
+    return lines
+        .slice(0, end)
+        .map((line) => `${line}\n`)
+        .join('');
+}
+/* The fence a line leaves open: it opens one, closes the one that is open, or changes nothing. */
+function nextFence(fence, line) {
+    const match = FENCE.exec(line);
+    if (!match) {
+        return fence;
+    }
+    const indent = match[1].length;
+    const run = match[2];
+    const rest = match[3];
+    if (fence === null) {
+        // A backtick fence's info string may not hold a backtick, or the line is inline code.
+        if (run[0] === '`' && rest.includes('`')) {
+            return null;
+        }
+        return { marker: run[0], length: run.length, indent };
+    }
+    // A closing fence carries no info string, and a line far deeper than the opening is code.
+    if (run[0] === fence.marker && run.length >= fence.length && BLANK.test(rest) && indent <= fence.indent + CLOSING_INDENT) {
+        return null;
+    }
+    return fence;
+}
+function isFenceOpenAtEnd(text) {
+    let fence = null;
+    for (const line of text.split('\n')) {
+        fence = nextFence(fence, line);
+    }
+    return fence !== null;
+}

package/dist/chat/ui/quote-selection.d.ts

@@ -0,0 +1,3 @@
+export type QuoteTaker = (quote: string) => void;
+export declare const QuoteTakerContext: import("react").Context<((take: QuoteTaker) => () => void) | null>;
+export declare function selectedAnswerQuote(selection: Selection | null, thread: HTMLElement | null): string | null;