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

package/dist/chat/drafts.d.ts

@@ -0,0 +1,29 @@
+import type { ChatAttachmentUpload } from '@adecore/agent-contracts';
+export interface ChatDraft {
+    text: string;
+    mentions: string[];
+    skills: string[];
+    chats: string[];
+    attachments: ChatAttachmentUpload[];
+    quote: string;
+}
+export declare const EMPTY_DRAFT: ChatDraft;
+export declare function isEmptyDraft(draft: ChatDraft): boolean;
+export declare const useDrafts: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    ids: string[];
+}>>;
+export declare function useHasDraft(chatId: string): boolean;
+export declare function readDraft(chatId: string): ChatDraft;
+export declare function writeDraft(chatId: string, draft: ChatDraft): void;
+export declare function joinDraftText(current: string, added: string): string;
+export declare function takeBackIntoDraft(current: ChatDraft, taken: Omit<ChatDraft, 'quote'>): {
+    draft: ChatDraft;
+    rejected: Array<{
+        name: string;
+        reason: string;
+    }>;
+};
+type DraftTaker = (text: string) => void;
+export declare function takeDraftOffers(chatId: string, take: DraftTaker): () => void;
+export declare function offerDraft(chatId: string, text: string): void;
+export {};

package/dist/chat/drafts.js

@@ -0,0 +1,116 @@
+import { chatStorageKey, chatStorageLegacyKeys, createChatStore } from '../storage.js';
+import { checkAttachmentLimits, uploadBytes } from './attachments.js';
+import { persistedJson } from './persisted-json.js';
+const storageKey = () => chatStorageKey('drafts');
+export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
+const storage = persistedJson(storageKey, (raw) => (raw ? JSON.parse(raw) : {}), {}, () => chatStorageLegacyKeys('drafts'));
+function readAll() {
+    return storage.read();
+}
+function store(drafts) {
+    return storage.write(drafts);
+}
+export function isEmptyDraft(draft) {
+    return draft.text.trim() === '' && draft.attachments.length === 0 && draft.quote === '';
+}
+/*
+ * Which chats hold an unsent prompt, for a dot beside them in a list of chats. The drafts themselves
+ * stay in storage: a node that is not on screen has no composer, and this is all anyone else needs.
+ */
+export const useDrafts = createChatStore(() => ({ ids: [] }), (store) => store.setState({ ids: Object.keys(readAll()) }));
+export function useHasDraft(chatId) {
+    return useDrafts((s) => s.ids.includes(chatId));
+}
+function trackDraft(chatId, held) {
+    const { ids } = useDrafts.getState();
+    if (ids.includes(chatId) === held) {
+        return;
+    }
+    useDrafts.setState({ ids: held ? [...ids, chatId] : ids.filter((id) => id !== chatId) });
+}
+/* An unsent prompt per chat node, kept across reloads so a half-written message is never lost. */
+export function readDraft(chatId) {
+    const record = readAll()[chatId];
+    return record
+        ? {
+            text: record.text,
+            mentions: record.mentions ?? [],
+            skills: record.skills ?? [],
+            chats: record.chats ?? [],
+            attachments: record.attachments ?? [],
+            quote: record.quote ?? ''
+        }
+        : EMPTY_DRAFT;
+}
+export function writeDraft(chatId, draft) {
+    const drafts = readAll();
+    trackDraft(chatId, !isEmptyDraft(draft));
+    if (isEmptyDraft(draft)) {
+        delete drafts[chatId];
+        store(drafts);
+        return;
+    }
+    drafts[chatId] = {
+        text: draft.text,
+        mentions: draft.mentions,
+        skills: draft.skills,
+        chats: draft.chats,
+        attachments: draft.attachments,
+        quote: draft.quote
+    };
+    if (store(drafts)) {
+        return;
+    }
+    // A file can outgrow the storage quota; the text is the part worth keeping then.
+    drafts[chatId] = { text: draft.text, mentions: draft.mentions, skills: draft.skills, chats: draft.chats, quote: draft.quote };
+    store(drafts);
+}
+/* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
+export function joinDraftText(current, added) {
+    return current.trim() === '' ? added : `${current.replace(/\s+$/, '')}\n\n${added}`;
+}
+function union(first, second) {
+    return [...first, ...second.filter((entry) => !first.includes(entry))];
+}
+/*
+ * A queued message taken back to edit goes above what was typed since. Its files join the draft's as
+ * far as the limits let them, and the rest come back rejected, the way a dropped file would. A quote
+ * it was sent with is part of its text; the draft keeps the one it holds.
+ */
+export function takeBackIntoDraft(current, taken) {
+    const checked = checkAttachmentLimits(current.attachments.length, taken.attachments.map((upload) => ({ name: upload.name, mime: upload.mime, bytes: uploadBytes(upload), upload })), current.attachments.reduce((bytes, upload) => bytes + uploadBytes(upload), 0));
+    return {
+        draft: {
+            text: current.text.trim() === '' ? taken.text : joinDraftText(taken.text, current.text),
+            mentions: union(taken.mentions, current.mentions),
+            skills: union(taken.skills, current.skills),
+            chats: union(taken.chats, current.chats),
+            attachments: [...checked.accepted.map((entry) => entry.upload), ...current.attachments],
+            quote: current.quote
+        },
+        rejected: checked.rejected
+    };
+}
+/* The composers on screen, by chat. One that is not mounted reads what was offered from storage when it is. */
+const takers = new Map();
+export function takeDraftOffers(chatId, take) {
+    takers.set(chatId, take);
+    return () => {
+        if (takers.get(chatId) === take) {
+            takers.delete(chatId);
+        }
+    };
+}
+/*
+ * Puts text in a chat's prompt without sending it: the person reads it and presses Enter. A mounted
+ * composer owns its draft and writes it back to storage itself, so it has to be the one to take it.
+ */
+export function offerDraft(chatId, text) {
+    const take = takers.get(chatId);
+    if (take) {
+        take(text);
+        return;
+    }
+    const current = readDraft(chatId);
+    writeDraft(chatId, { ...current, text: joinDraftText(current.text, text) });
+}

package/dist/chat/forks.d.ts

@@ -0,0 +1,2 @@
+export declare function useForkedTurns(chatId: string): ReadonlySet<string>;
+export declare function useForkIdsAfter(chatId: string, turnId: string): string[];

package/dist/chat/forks.js

@@ -0,0 +1,28 @@
+import { useMemo } from 'react';
+import { forkIdsAfter, forkedTurnIds } from './logic/fork.js';
+import { useChatScope } from '../scope.js';
+import { useChats } from '../state/chats.js';
+/* The chats this client holds of one host, which is where the forks it knows of are. */
+function* forkInfosOn(byKey, owns) {
+    for (const [key, state] of Object.entries(byKey)) {
+        if (state.info.forkOf !== undefined && owns(key)) {
+            yield state.info;
+        }
+    }
+}
+/* Selectors answer a joined string, never a new array or set, and split it again in a memo. */
+function splitIds(joined) {
+    return joined === '' ? [] : joined.split('\n');
+}
+/* The turns of this chat a fork went on after, for the thread to put a line under. */
+export function useForkedTurns(chatId) {
+    const { owns } = useChatScope();
+    const joined = useChats((s) => [...forkedTurnIds(forkInfosOn(s.byKey, owns), chatId)].join('\n'));
+    return useMemo(() => new Set(splitIds(joined)), [joined]);
+}
+/* The forks that went on after this turn of this chat. */
+export function useForkIdsAfter(chatId, turnId) {
+    const { owns } = useChatScope();
+    const joined = useChats((s) => forkIdsAfter(forkInfosOn(s.byKey, owns), chatId, turnId).join('\n'));
+    return useMemo(() => splitIds(joined), [joined]);
+}

package/dist/chat/guards.d.ts

@@ -0,0 +1,12 @@
+export declare const PROMPT_MAX_CHARS = 120000;
+export declare const PROMPT_COUNTER_FROM = 100000;
+export declare const PASTE_ATTACHMENT_FROM_BYTES: number;
+export declare function pasteBecomesAttachment(text: string): boolean;
+export declare function pastedTextName(taken: string[]): string;
+export interface PromptGuard {
+    count: number;
+    visible: boolean;
+    tooLong: boolean;
+}
+export declare function promptGuard(text: string): PromptGuard;
+export declare function usableSlashCommands(names: string[]): string[];

package/dist/chat/guards.js

@@ -0,0 +1,69 @@
+// What a CLI still accepts without the turn becoming slower than the answer is worth; a Claude user
+// frame this large is legal but sluggish.
+export const PROMPT_MAX_CHARS = 120000;
+// Below this the counter would only be noise; a prompt this long is already unusual.
+export const PROMPT_COUNTER_FROM = 100000;
+/*
+ * From this many bytes a paste of text becomes a file beside the prompt instead of text in it. A log
+ * or a file that large is something to read with a tool, not words for the model to take in on
+ * every turn, and in the textarea it buries what the person actually wants to say.
+ */
+export const PASTE_ATTACHMENT_FROM_BYTES = 32 * 1024;
+const encoder = new TextEncoder();
+/* Whether pasted text is large enough to go in as an attachment. Bytes, since that is what the file weighs. */
+export function pasteBecomesAttachment(text) {
+    return text.length * 3 >= PASTE_ATTACHMENT_FROM_BYTES && encoder.encode(text).length >= PASTE_ATTACHMENT_FROM_BYTES;
+}
+/* A name for pasted text that no attachment of the draft has yet: paste-1.txt, paste-2.txt, ... */
+export function pastedTextName(taken) {
+    const names = new Set(taken);
+    let index = 1;
+    while (names.has(`paste-${index}.txt`)) {
+        index += 1;
+    }
+    return `paste-${index}.txt`;
+}
+export function promptGuard(text) {
+    return {
+        count: text.length,
+        visible: text.length >= PROMPT_COUNTER_FROM,
+        tooLong: text.length > PROMPT_MAX_CHARS
+    };
+}
+/*
+ * Commands the CLI lists because its own terminal has them: they change the terminal, the login or
+ * the config, or they end a session the chat node does not own.
+ */
+const TUI_ONLY = new Set([
+    'bug',
+    'color',
+    'config',
+    'doctor',
+    'exit',
+    'heapdump',
+    'help',
+    'hooks',
+    'ide',
+    'install-github-app',
+    'keybindings',
+    'login',
+    'logout',
+    'migrate-installer',
+    'privacy-settings',
+    'quit',
+    'release-notes',
+    'reload-plugins',
+    'reload-skills',
+    'rename',
+    'resume',
+    'status',
+    'statusline',
+    'terminal-setup',
+    'theme',
+    'upgrade',
+    'vim'
+]);
+/* The commands of the CLI's list that mean something in a chat node. */
+export function usableSlashCommands(names) {
+    return names.filter((name) => !TUI_ONLY.has(name));
+}

package/dist/chat/logic/ansi.d.ts

@@ -0,0 +1,13 @@
+import type { CSSProperties } from 'react';
+export interface AnsiToken {
+    content: string;
+    style: CSSProperties;
+}
+export declare function stripAnsi(text: string): string;
+export declare function parseAnsi(text: string, options?: {
+    limit?: number;
+    tailLines?: number;
+}): {
+    tokens: AnsiToken[];
+    omitted: number;
+};

package/dist/chat/logic/ansi.js

@@ -0,0 +1,185 @@
+const COLORS = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
+const COLOR_LEVELS = [0, 95, 135, 175, 215, 255];
+// Consume non-color controls too, so cursor commands and OSC links never become visible text or HTML.
+/* oxlint-disable no-control-regex */
+const ESCAPES = /(?:\x1b\[|\x9b)([0-?]*[ -/]*)([@-~]|$)|(?:\x1b\]|\x9d)[^\x07\x1b\x9c]*(?:\x07|\x1b\\|\x9c|$)|\x1b[PX^_][^\x1b\x9c]*(?:\x1b\\|\x9c|$)|\x1b[ -/]*[@-~]|\x1b$|[\x00-\x08\x0b\x0c\x0e-\x1a\x1c-\x1f\x7f-\x9f]/g;
+/* oxlint-enable no-control-regex */
+export function stripAnsi(text) {
+    return text.replace(ESCAPES, '');
+}
+function rgb(channels) {
+    if (channels.length !== 3 || channels.some((channel) => !Number.isInteger(channel) || channel < 0 || channel > 255)) {
+        return undefined;
+    }
+    return `rgb(${channels.join(' ')})`;
+}
+function paletteColor(index) {
+    if (!Number.isInteger(index) || index < 0 || index > 255) {
+        return undefined;
+    }
+    if (index < 16) {
+        return `var(--term-ansi-${index >= 8 ? 'bright-' : ''}${COLORS[index % 8]})`;
+    }
+    if (index < 232) {
+        const cube = index - 16;
+        return rgb([COLOR_LEVELS[Math.floor(cube / 36)], COLOR_LEVELS[Math.floor(cube / 6) % 6], COLOR_LEVELS[cube % 6]]);
+    }
+    const gray = 8 + (index - 232) * 10;
+    return rgb([gray, gray, gray]);
+}
+function extendedColor(parameters) {
+    const mode = parameters[0];
+    if (mode === '5' && parameters.length === 2 && parameters[1] !== '') {
+        return paletteColor(Number(parameters[1]));
+    }
+    if (mode === '2') {
+        // Colon-form RGB may include an empty color-space parameter before its three channels.
+        const channels = parameters.length === 5 ? parameters.slice(2) : parameters.slice(1);
+        return rgb(channels.map((channel) => (channel === '' ? NaN : Number(channel))));
+    }
+    return undefined;
+}
+function applyRendition(state, parameters) {
+    if (!/^[\d;:]*$/.test(parameters)) {
+        return state;
+    }
+    const values = parameters.split(';');
+    for (let i = 0; i < values.length; i++) {
+        const parts = values[i].split(':');
+        const code = Number(parts[0]);
+        if (code === 38 || code === 48) {
+            let color;
+            if (parts.length > 1) {
+                color = extendedColor(parts.slice(1));
+            }
+            else {
+                const count = values[i + 1] === '2' ? 4 : values[i + 1] === '5' ? 2 : 1;
+                color = extendedColor(values.slice(i + 1, i + 1 + count));
+                i += count;
+            }
+            if (color !== undefined) {
+                state[code === 38 ? 'foreground' : 'background'] = color;
+            }
+        }
+        else if (code >= 30 && code <= 37) {
+            state.foreground = paletteColor(code - 30);
+        }
+        else if (code >= 40 && code <= 47) {
+            state.background = paletteColor(code - 40);
+        }
+        else if (code >= 90 && code <= 97) {
+            state.foreground = paletteColor(code - 90 + 8);
+        }
+        else if (code >= 100 && code <= 107) {
+            state.background = paletteColor(code - 100 + 8);
+        }
+        else {
+            switch (code) {
+                case 0:
+                    state = {};
+                    break;
+                case 1:
+                    state.bold = true;
+                    break;
+                case 2:
+                    state.dim = true;
+                    break;
+                case 3:
+                    state.italic = true;
+                    break;
+                case 4:
+                    state.underline = parts[1] !== '0';
+                    break;
+                case 7:
+                    state.inverse = true;
+                    break;
+                case 9:
+                    state.strike = true;
+                    break;
+                case 22:
+                    state.bold = false;
+                    state.dim = false;
+                    break;
+                case 23:
+                    state.italic = false;
+                    break;
+                case 24:
+                    state.underline = false;
+                    break;
+                case 27:
+                    state.inverse = false;
+                    break;
+                case 29:
+                    state.strike = false;
+                    break;
+                case 39:
+                    state.foreground = undefined;
+                    break;
+                case 49:
+                    state.background = undefined;
+                    break;
+            }
+        }
+    }
+    return state;
+}
+function styleOf(state) {
+    const style = {};
+    const color = state.inverse ? (state.background ?? 'var(--chat-code-bg)') : state.foreground;
+    const background = state.inverse ? (state.foreground ?? 'var(--chat-output)') : state.background;
+    if (color !== undefined || state.dim) {
+        style.color = state.dim ? `color-mix(in srgb, ${color ?? 'currentColor'} 65%, transparent)` : color;
+    }
+    if (background !== undefined) {
+        style.backgroundColor = background;
+    }
+    if (state.bold) {
+        style.fontWeight = 'bold';
+    }
+    if (state.italic) {
+        style.fontStyle = 'italic';
+    }
+    if (state.underline || state.strike) {
+        style.textDecorationLine = [state.underline && 'underline', state.strike && 'line-through'].filter(Boolean).join(' ');
+    }
+    return style;
+}
+export function parseAnsi(text, options = {}) {
+    const tokens = [];
+    let state = {};
+    let position = 0;
+    for (const match of text.matchAll(ESCAPES)) {
+        if (match.index > position) {
+            tokens.push({ content: text.slice(position, match.index), style: styleOf(state) });
+        }
+        if (match[2] === 'm') {
+            state = applyRendition(state, match[1]);
+        }
+        position = match.index + match[0].length;
+    }
+    if (position < text.length) {
+        tokens.push({ content: text.slice(position), style: styleOf(state) });
+    }
+    const plain = tokens.map((token) => token.content).join('');
+    let start = 0;
+    let end = plain.length;
+    if (options.tailLines !== undefined) {
+        if (plain.endsWith('\n')) {
+            end--;
+        }
+        const tail = plain.slice(0, end).split('\n').slice(-options.tailLines).join('\n');
+        start = end - tail.length;
+    }
+    const omitted = options.limit === undefined ? 0 : Math.max(0, end - start - options.limit);
+    end -= omitted;
+    let offset = 0;
+    return {
+        tokens: tokens.flatMap((token) => {
+            const from = Math.max(0, start - offset);
+            const to = Math.min(token.content.length, end - offset);
+            offset += token.content.length;
+            return to > from ? [{ ...token, content: token.content.slice(from, to) }] : [];
+        }),
+        omitted
+    };
+}

package/dist/chat/logic/answers.d.ts

@@ -0,0 +1 @@
+export declare function toggleChoice(picked: string[], label: string): string[];

package/dist/chat/logic/answers.js

@@ -0,0 +1,8 @@
+/*
+ * Add or remove one choice of a multi select question. The picks stay a list here because a label
+ * may hold the separator itself: joined too early, such a label no longer matches itself and the
+ * choice would read as unpicked on screen.
+ */
+export function toggleChoice(picked, label) {
+    return picked.includes(label) ? picked.filter((choice) => choice !== label) : [...picked, label];
+}

package/dist/chat/logic/bookmarks.d.ts

@@ -0,0 +1,5 @@
+import type { ChatBookmark, ChatItem } from '@adecore/agent-contracts';
+import type { TimelineRow } from './timeline.js';
+export declare function bookmarkLabel(bookmark: ChatBookmark): string;
+export declare function bookmarksInThreadOrder(bookmarks: readonly ChatBookmark[], order: readonly string[]): ChatBookmark[];
+export declare function bookmarkRows(rows: readonly TimelineRow[], bookmarks: readonly ChatBookmark[], items: Readonly<Record<string, ChatItem>>): Map<string, ChatBookmark>;

package/dist/chat/logic/bookmarks.js

@@ -0,0 +1,33 @@
+/* What a list calls a bookmark: its name, else the start of the message. */
+export function bookmarkLabel(bookmark) {
+    return bookmark.name ?? bookmark.excerpt;
+}
+/* The bookmarks in the order of the thread; one whose message this client does not hold goes last. */
+export function bookmarksInThreadOrder(bookmarks, order) {
+    const places = new Map(order.map((id, index) => [id, index]));
+    const place = (bookmark) => places.get(bookmark.itemId) ?? order.length;
+    return [...bookmarks].sort((left, right) => place(left) - place(right) || left.createdAt - right.createdAt);
+}
+/*
+ * Which row each bookmark is drawn at, by row id: the message's own row, or the fold of a settled
+ * turn that hides a reply before its last one. A bookmark on a message this client does not hold
+ * has no row.
+ */
+export function bookmarkRows(rows, bookmarks, items) {
+    const rowIds = new Set(rows.map((row) => row.id));
+    const folds = new Map();
+    for (const row of rows) {
+        if (row.kind === 'turn-fold') {
+            folds.set(row.turn.id, row.id);
+        }
+    }
+    const marked = new Map();
+    for (const bookmark of bookmarks) {
+        const turnId = items[bookmark.itemId]?.turnId ?? null;
+        const rowId = rowIds.has(bookmark.itemId) ? bookmark.itemId : turnId === null ? undefined : folds.get(turnId);
+        if (rowId !== undefined && !marked.has(rowId)) {
+            marked.set(rowId, bookmark);
+        }
+    }
+    return marked;
+}

package/dist/chat/logic/context-usage.d.ts

@@ -0,0 +1,12 @@
+import type { ChatContextBreakdown, ChatUsage, ModelOptionDescriptor } from '@adecore/agent-contracts';
+export declare const CONTEXT_OPTION = "contextWindow";
+export type ContextPart = keyof ChatContextBreakdown;
+export declare const CONTEXT_PARTS: readonly ContextPart[];
+export interface ContextSegment {
+    part: ContextPart;
+    tokens: number;
+    fraction: number;
+}
+export declare function contextFraction(usage: ChatUsage): number;
+export declare function contextSegments(usage: ChatUsage): ContextSegment[] | null;
+export declare function orderOptions(options: readonly ModelOptionDescriptor[]): ModelOptionDescriptor[];

package/dist/chat/logic/context-usage.js

@@ -0,0 +1,21 @@
+export const CONTEXT_OPTION = 'contextWindow';
+export const CONTEXT_PARTS = ['toolOutput', 'filesRead', 'conversation', 'system'];
+export function contextFraction(usage) {
+    return usage.contextWindow ? Math.min(1, usage.contextTokens / usage.contextWindow) : 0;
+}
+/* The stretches of the bar, in the legend's order; null from a host that does not estimate, which draws the plain bar. */
+export function contextSegments(usage) {
+    const breakdown = usage.breakdown;
+    if (!breakdown || usage.contextTokens === 0) {
+        return null;
+    }
+    const whole = Math.max(usage.contextWindow ?? 0, usage.contextTokens);
+    return CONTEXT_PARTS.map((part) => ({ part, tokens: breakdown[part], fraction: breakdown[part] / whole }));
+}
+/*
+ * The model's own knobs with the context window last: its details sit in the group right under it,
+ * and a switch like Fast mode belongs with the reasoning choice above rather than below the size.
+ */
+export function orderOptions(options) {
+    return [...options.filter((option) => option.id !== CONTEXT_OPTION), ...options.filter((option) => option.id === CONTEXT_OPTION)];
+}

package/dist/chat/logic/fork.d.ts

@@ -0,0 +1,45 @@
+import type { AgentKind, ChatForkPayload, ChatInfo, ChatItem, ModelSelection } from '@adecore/agent-contracts';
+import type { TimelineRow } from './timeline.js';
+export declare const FORKABLE_PROVIDERS: ReadonlySet<string>;
+export interface ForkPoint {
+    turnId: string;
+    number: number;
+    total: number;
+    counted: boolean;
+    last: boolean;
+    prompt: string | null;
+}
+export declare function forkRefusal(info: ChatInfo | null, turn: ChatItem | undefined): string | null;
+export declare function summaryRefusal(state: {
+    busy: boolean;
+    originalPresent: boolean;
+}): string | null;
+export declare function forkIdsAfter(infos: Iterable<ChatInfo>, chatId: string, turnId: string): string[];
+export declare function forkedTurnIds(infos: Iterable<ChatInfo>, chatId: string): Set<string>;
+export declare function lastSettledTurn(items: Record<string, ChatItem>, order: readonly string[]): string | null;
+export declare function forkPointOf(items: Record<string, ChatItem>, order: readonly string[], turnId: string, whole: boolean): ForkPoint | null;
+export declare function forkPointLabel(point: ForkPoint, maxPrompt?: number): string;
+export declare function turnIdOfRow(row: TimelineRow): string | null;
+export type ForkShape = 'node' | 'view';
+export declare function forkShapes(origin: ForkShape): ForkShape[];
+export interface ForkWorktreeChoice {
+    branch: string;
+    filesAfterTurn: boolean;
+}
+export interface ForkCliChoice {
+    provider: AgentKind;
+    selection: ModelSelection;
+    account?: string;
+}
+export declare function forkPayload(input: {
+    chatId: string;
+    turnId: string;
+    title: string;
+    shape: ForkShape;
+    worktree?: ForkWorktreeChoice | null;
+    cli?: {
+        original: ForkCliChoice;
+        chosen: ForkCliChoice;
+    };
+}): ChatForkPayload;
+export declare function branchRefusal(branch: string, taken: readonly string[]): string | null;