@bubblebrain-ai/bubble 0.0.4 → 0.0.5

package/dist/tools/edit-apply.js

@@ -0,0 +1,197 @@
+export class EditApplyError extends Error {
+    status;
+    constructor(message, status = "no_match") {
+        super(message);
+        this.status = status;
+        this.name = "EditApplyError";
+    }
+}
+function detectLineEnding(content) {
+    const crlf = content.indexOf("\r\n");
+    const lf = content.indexOf("\n");
+    return crlf !== -1 && crlf === lf - 1 ? "\r\n" : "\n";
+}
+function stripBom(content) {
+    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function normalizeToLF(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function restoreLineEndings(text, lineEnding) {
+    return lineEnding === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+function normalizeLineForMatch(line) {
+    return line
+        .normalize("NFKC")
+        .trimEnd()
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+function findAllOccurrences(content, needle) {
+    const indexes = [];
+    if (needle.length === 0)
+        return indexes;
+    let index = content.indexOf(needle);
+    while (index !== -1) {
+        indexes.push(index);
+        index = content.indexOf(needle, index + needle.length);
+    }
+    return indexes;
+}
+function splitLines(content) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === "\n") {
+            lines.push({ text: content.slice(start, i), start, endNoNewline: i });
+            start = i + 1;
+        }
+    }
+    lines.push({ text: content.slice(start), start, endNoNewline: content.length });
+    return lines;
+}
+function nonBlankLines(lines) {
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        const normalized = normalizeLineForMatch(lines[i].text);
+        if (normalized.trim().length > 0) {
+            result.push({ lineIndex: i, normalized });
+        }
+    }
+    return result;
+}
+function normalizedOldNonBlankLines(oldText) {
+    return splitLines(oldText)
+        .map((line) => normalizeLineForMatch(line.text))
+        .filter((line) => line.trim().length > 0);
+}
+function findNormalizedLineMatches(content, oldText) {
+    const contentLines = splitLines(content);
+    const searchable = nonBlankLines(contentLines);
+    const oldLines = normalizedOldNonBlankLines(oldText);
+    if (oldLines.length === 0)
+        return [];
+    const matches = [];
+    for (let i = 0; i <= searchable.length - oldLines.length; i++) {
+        let matched = true;
+        for (let j = 0; j < oldLines.length; j++) {
+            if (searchable[i + j].normalized !== oldLines[j]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            const first = contentLines[searchable[i].lineIndex];
+            const last = contentLines[searchable[i + oldLines.length - 1].lineIndex];
+            matches.push({ start: first.start, end: last.endNoNewline });
+        }
+    }
+    return matches;
+}
+function summarizeOldText(oldText) {
+    const firstLine = normalizeToLF(oldText).split("\n").find((line) => line.trim().length > 0) ?? oldText;
+    return firstLine.length > 80 ? `${firstLine.slice(0, 80)}...` : firstLine;
+}
+function findBestLineHint(content, oldText) {
+    const oldLines = normalizedOldNonBlankLines(oldText);
+    if (oldLines.length === 0)
+        return undefined;
+    const contentLines = nonBlankLines(splitLines(content));
+    let best;
+    for (let i = 0; i < contentLines.length; i++) {
+        let score = 0;
+        for (let j = 0; j < oldLines.length && i + j < contentLines.length; j++) {
+            if (contentLines[i + j].normalized === oldLines[j])
+                score++;
+        }
+        if (!best || score > best.score)
+            best = { index: i, score };
+    }
+    if (!best || best.score === 0)
+        return undefined;
+    const startLine = contentLines[best.index].lineIndex + 1;
+    return `Closest line-based candidate starts near line ${startLine} and matched ${best.score}/${oldLines.length} non-blank lines.`;
+}
+function matchEdit(content, edit, index, total) {
+    if (edit.oldText.length === 0) {
+        throw new EditApplyError(total === 1 ? "Error: oldText must not be empty." : `Error: edits[${index}].oldText must not be empty.`);
+    }
+    const oldText = normalizeToLF(edit.oldText);
+    const exact = findAllOccurrences(content, oldText);
+    if (exact.length === 1) {
+        return { editIndex: index, mode: "exact", start: exact[0], end: exact[0] + oldText.length };
+    }
+    if (exact.length > 1) {
+        throw new EditApplyError(total === 1
+            ? `Error: oldText appears ${exact.length} times in file. Must be unique: "${summarizeOldText(oldText)}"`
+            : `Error: edits[${index}].oldText appears ${exact.length} times in file. Must be unique: "${summarizeOldText(oldText)}"`);
+    }
+    const normalizedLineMatches = findNormalizedLineMatches(content, oldText);
+    if (normalizedLineMatches.length === 1) {
+        return {
+            editIndex: index,
+            mode: "normalized-line",
+            start: normalizedLineMatches[0].start,
+            end: normalizedLineMatches[0].end,
+        };
+    }
+    if (normalizedLineMatches.length > 1) {
+        throw new EditApplyError(total === 1
+            ? `Error: oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`
+            : `Error: edits[${index}].oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`);
+    }
+    const hint = findBestLineHint(content, oldText);
+    const suffix = hint ? `\n${hint}` : "";
+    throw new EditApplyError(total === 1
+        ? `Error: oldText not found in file: "${summarizeOldText(oldText)}"${suffix}`
+        : `Error: edits[${index}].oldText not found in file: "${summarizeOldText(oldText)}"${suffix}`);
+}
+function assertNoOverlaps(matches) {
+    const sorted = [...matches].sort((a, b) => a.start - b.start);
+    for (let i = 1; i < sorted.length; i++) {
+        const previous = sorted[i - 1];
+        const current = sorted[i];
+        if (previous.end > current.start) {
+            throw new EditApplyError(`Error: edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in file. Merge them into one edit or target disjoint regions.`, "blocked");
+        }
+    }
+}
+export function applyEditsToContent(rawContent, edits) {
+    if (!Array.isArray(edits) || edits.length === 0) {
+        throw new EditApplyError("Error: No edits provided");
+    }
+    const { bom, text } = stripBom(rawContent);
+    const lineEnding = detectLineEnding(text);
+    const normalizedOriginal = normalizeToLF(text);
+    const normalizedEdits = edits.map((edit) => ({
+        oldText: normalizeToLF(edit.oldText),
+        newText: normalizeToLF(edit.newText),
+    }));
+    const matches = normalizedEdits.map((edit, index) => matchEdit(normalizedOriginal, edit, index, normalizedEdits.length));
+    assertNoOverlaps(matches);
+    const byDescendingStart = [...matches].sort((a, b) => b.start - a.start);
+    let normalizedNext = normalizedOriginal;
+    for (const match of byDescendingStart) {
+        const edit = normalizedEdits[match.editIndex];
+        normalizedNext = normalizedNext.slice(0, match.start) + edit.newText + normalizedNext.slice(match.end);
+    }
+    if (normalizedNext === normalizedOriginal) {
+        throw new EditApplyError("Error: No changes made. The replacement produced identical content.");
+    }
+    return {
+        content: bom + restoreLineEndings(normalizedNext, lineEnding),
+        normalizedOriginal,
+        normalizedNext,
+        bom,
+        lineEnding,
+        matches,
+    };
+}
+export function formatEditMatchNotes(matches) {
+    const normalizedCount = matches.filter((match) => match.mode !== "exact").length;
+    if (normalizedCount === 0)
+        return "";
+    return `\n\nNote: ${normalizedCount} edit${normalizedCount === 1 ? "" : "s"} applied using normalized line matching for whitespace/formatting differences.`;
+}

package/dist/tools/edit.js

@@ -5,14 +5,22 @@
  */
 import { constants } from "node:fs";
 import { access, readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 import { createTwoFilesPatch } from "diff";
 import { gateToolAction } from "../approval/tool-helper.js";
 import { formatDiagnosticBlocks } from "../lsp/index.js";
+import { applyEditsToContent, EditApplyError, formatEditMatchNotes } from "./edit-apply.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+function isWithinWorkspace(cwd, filePath) {
+    const rel = relative(resolve(cwd), filePath);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
 export function createEditTool(cwd, approval, lsp) {
     return {
         name: "edit",
-        description: "Apply targeted string replacements to a file. Each oldText must match exactly once. All edits apply to the original file contents simultaneously.",
+        effect: "write_direct",
+        requiresApproval: true,
+        description: "Apply targeted string replacements to a file. Prefer exact oldText. The tool can tolerate line ending, trailing whitespace, Unicode punctuation/space, and blank-line differences only when the target is unique.",
         parameters: {
             type: "object",
             properties: {
@@ -34,67 +42,66 @@ export function createEditTool(cwd, approval, lsp) {
         },
         async execute(args) {
             const filePath = resolve(cwd, args.path);
-            try {
-                await access(filePath, constants.R_OK | constants.W_OK);
-            }
-            catch {
-                return { content: `Error: Cannot read/write file: ${filePath}`, isError: true };
-            }
-            const original = await readFile(filePath, "utf-8");
-            let content = original;
-            const edits = args.edits;
-            if (!Array.isArray(edits) || edits.length === 0) {
-                return { content: "Error: No edits provided", isError: true };
+            if (!isWithinWorkspace(cwd, filePath)) {
+                return {
+                    content: `Error: Edit path is outside the workspace: ${filePath}`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: {
+                        kind: "security",
+                        path: filePath,
+                        reason: "Edit path is outside the workspace.",
+                    },
+                };
             }
-            // Validate each oldText exists exactly once
-            for (const edit of edits) {
-                const count = content.split(edit.oldText).length - 1;
-                if (count === 0) {
-                    return {
-                        content: `Error: oldText not found in file: "${edit.oldText.slice(0, 50)}..."`,
-                        isError: true,
-                    };
+            return withFileMutationQueue(filePath, async () => {
+                try {
+                    await access(filePath, constants.R_OK | constants.W_OK);
                 }
-                if (count > 1) {
-                    return {
-                        content: `Error: oldText appears ${count} times in file. Must be unique: "${edit.oldText.slice(0, 50)}..."`,
-                        isError: true,
-                    };
+                catch {
+                    return { content: `Error: Cannot read/write file: ${filePath}`, isError: true };
                 }
-            }
-            // Apply all edits in-memory to compute the proposed next content + diff.
-            for (const edit of edits) {
-                content = content.replace(edit.oldText, edit.newText);
-            }
-            const diff = createTwoFilesPatch(filePath, filePath, original, content, "original", "modified", { context: 3 });
-            // Gate on the approval controller BEFORE persisting the change.
-            const gate = await gateToolAction(approval, {
-                type: "edit",
-                path: filePath,
-                diff,
-                fileExists: true,
-            });
-            if (!gate.approved)
-                return gate.result;
-            await writeFile(filePath, content, "utf-8");
-            let output = `Edited ${filePath}\n\nDiff:\n${diff}`;
-            if (lsp) {
+                const original = await readFile(filePath, "utf-8");
+                let applied;
                 try {
-                    await lsp.touchFile(filePath, "document");
-                    output += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                    applied = applyEditsToContent(original, args.edits);
                 }
-                catch {
-                    // LSP diagnostics should not turn a successful edit into a failed tool call.
+                catch (err) {
+                    if (err instanceof EditApplyError) {
+                        return { content: err.message, isError: true, status: err.status };
+                    }
+                    throw err;
                 }
-            }
-            return {
-                content: output,
-                status: "success",
-                metadata: {
-                    kind: "edit",
+                const diff = createTwoFilesPatch(filePath, filePath, original, applied.content, "original", "modified", { context: 3 });
+                // Gate on the approval controller BEFORE persisting the change.
+                const gate = await gateToolAction(approval, {
+                    type: "edit",
                     path: filePath,
-                },
-            };
+                    diff,
+                    fileExists: true,
+                });
+                if (!gate.approved)
+                    return gate.result;
+                await writeFile(filePath, applied.content, "utf-8");
+                let output = `Edited ${filePath}${formatEditMatchNotes(applied.matches)}\n\nDiff:\n${diff}`;
+                if (lsp) {
+                    try {
+                        await lsp.touchFile(filePath, "document");
+                        output += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                    }
+                    catch {
+                        // LSP diagnostics should not turn a successful edit into a failed tool call.
+                    }
+                }
+                return {
+                    content: output,
+                    status: "success",
+                    metadata: {
+                        kind: "edit",
+                        path: filePath,
+                    },
+                };
+            });
         },
     };
 }

package/dist/tools/exit-plan-mode.js

@@ -9,7 +9,9 @@ export function createExitPlanModeTool(controller) {
     return {
         name: "exit_plan_mode",
         readOnly: true,
-        description: "ONLY call this tool when the harness has told you (via a <system-reminder>) that plan mode is ACTIVE. " +
+        effect: "read",
+        requiresApproval: true,
+        description: "ONLY call this tool when the harness has told you via a runtime reminder that plan mode is ACTIVE. " +
             "Do NOT call it during ordinary work — in default mode you should just use the regular tools directly. " +
             "In plan mode: after investigating, call this with a concrete step-by-step plan so the user can approve, edit, or reject. " +
             "Approval automatically switches the agent out of plan mode.",

package/dist/tools/file-mutation-queue.d.ts

@@ -0,0 +1 @@
+export declare function withFileMutationQueue<T>(filePath: string, fn: () => Promise<T>): Promise<T>;

package/dist/tools/file-mutation-queue.js

@@ -0,0 +1,32 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+const queues = new Map();
+function queueKey(filePath) {
+    const resolved = resolve(filePath);
+    try {
+        return realpathSync.native(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export async function withFileMutationQueue(filePath, fn) {
+    const key = queueKey(filePath);
+    const current = queues.get(key) ?? Promise.resolve();
+    let release;
+    const next = new Promise((resolveNext) => {
+        release = resolveNext;
+    });
+    const chained = current.then(() => next);
+    queues.set(key, chained);
+    await current;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (queues.get(key) === chained) {
+            queues.delete(key);
+        }
+    }
+}

package/dist/tools/glob.js

@@ -20,6 +20,7 @@ export function createGlobTool(cwd) {
     return {
         name: "glob",
         readOnly: true,
+        effect: "read",
         description: `Find files by glob pattern without using the shell. Use this for project structure discovery and filename searches. Returns up to ${MAX_RESULTS} files sorted by recent modification time.`,
         parameters: {
             type: "object",

package/dist/tools/grep.js

@@ -10,6 +10,7 @@ export function createGrepTool(cwd) {
     return {
         name: "grep",
         readOnly: true,
+        effect: "read",
         description: `Search file contents using regex (via ripgrep). Use this instead of running grep, rg, or ripgrep through bash. Returns up to ${MAX_MATCHES} matches.`,
         parameters: {
             type: "object",

package/dist/tools/index.d.ts

@@ -11,7 +11,7 @@ export { createLspTool } from "./lsp.js";
 export { createWebFetchTool } from "./web-fetch.js";
 export { createWebSearchTool } from "./web-search.js";
 export { createSkillTool } from "./skill.js";
-export { createTaskTool } from "./task.js";
+export { createAgentLifecycleTools, createCloseAgentTool, createSendInputTool, createSpawnAgentTool, createWaitAgentTool } from "./agent-lifecycle.js";
 export { createTodoTool, type TodoStore } from "./todo.js";
 export { createExitPlanModeTool, type PlanController } from "./exit-plan-mode.js";
 export { createToolSearchTool, type ToolSearchController } from "./tool-search.js";

package/dist/tools/index.js

@@ -11,7 +11,7 @@ export { createLspTool } from "./lsp.js";
 export { createWebFetchTool } from "./web-fetch.js";
 export { createWebSearchTool } from "./web-search.js";
 export { createSkillTool } from "./skill.js";
-export { createTaskTool } from "./task.js";
+export { createAgentLifecycleTools, createCloseAgentTool, createSendInputTool, createSpawnAgentTool, createWaitAgentTool } from "./agent-lifecycle.js";
 export { createTodoTool } from "./todo.js";
 export { createExitPlanModeTool } from "./exit-plan-mode.js";
 export { createToolSearchTool } from "./tool-search.js";
@@ -26,7 +26,7 @@ import { getLspService } from "../lsp/index.js";
 import { createLspTool } from "./lsp.js";
 import { createReadTool } from "./read.js";
 import { createSkillTool } from "./skill.js";
-import { createTaskTool } from "./task.js";
+import { createAgentLifecycleTools } from "./agent-lifecycle.js";
 import { createTodoTool } from "./todo.js";
 import { createToolSearchTool } from "./tool-search.js";
 import { createWebFetchTool } from "./web-fetch.js";
@@ -49,7 +49,7 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
         createWebFetchTool(approval),
         createMemorySearchTool(cwd),
         createMemoryReadSummaryTool(cwd),
-        createTaskTool(),
+        ...createAgentLifecycleTools(),
         ...(options.questionController ? [createQuestionTool(options.questionController)] : []),
         ...(skillRegistry ? [createSkillTool(skillRegistry)] : []),
         ...(options.todoStore ? [createTodoTool(options.todoStore)] : []),

package/dist/tools/lsp.js

@@ -18,6 +18,8 @@ export function createLspTool(cwd, lsp = getLspService(cwd), approval) {
     return {
         name: "lsp",
         readOnly: true,
+        effect: "read",
+        requiresApproval: true,
         description: "Use the language server for code navigation. Supports goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, and outgoingCalls.",
         parameters: {
             type: "object",

package/dist/tools/memory.js

@@ -5,6 +5,7 @@ export function createMemorySearchTool(cwd) {
         name: "memory_search",
         description: "Search persistent Bubble memory for prior project facts, user preferences, workflows, decisions, and gotchas.",
         readOnly: true,
+        effect: "read",
         parameters: {
             type: "object",
             properties: {
@@ -56,6 +57,7 @@ export function createMemoryReadSummaryTool(cwd) {
         name: "memory_read_summary",
         description: "Read the concise persistent memory summary for the current project, global scope, or both.",
         readOnly: true,
+        effect: "read",
         parameters: {
             type: "object",
             properties: {

package/dist/tools/question.js

@@ -3,6 +3,8 @@ export function createQuestionTool(controller) {
     return {
         name: "question",
         readOnly: true,
+        effect: "read",
+        requiresApproval: true,
         description: `Ask the user one or more structured questions during execution.
 
 Use this when you need to:

package/dist/tools/read.js

@@ -11,6 +11,7 @@ export function createReadTool(cwd, approval, lsp) {
     return {
         name: "read",
         readOnly: true,
+        effect: "read",
         description: `Read the contents of a file. Output is truncated to ${MAX_LINES} lines or ${MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files.`,
         parameters: {
             type: "object",

package/dist/tools/skill.js

@@ -21,6 +21,7 @@ export function createSkillTool(registry) {
     return {
         name: "skill",
         readOnly: true,
+        effect: "read",
         description: "Load a named skill on demand. Use this when a task clearly matches one of the available skills.",
         parameters: {
             type: "object",

package/dist/tools/task.js

@@ -2,6 +2,7 @@ export function createTaskTool() {
     return {
         name: "task",
         readOnly: true,
+        effect: "read",
         description: `Delegate a bounded investigative subtask to a read-only sub-agent and return a concise summary.
 
 Use this when:

package/dist/tools/todo.js

@@ -8,6 +8,7 @@ export function createTodoTool(store) {
     return {
         name: "todo_write",
         readOnly: true,
+        effect: "read",
         description: `Create or update the task list for the current work. Send the COMPLETE list each call; this overwrites the prior list entirely.
 
 ## When to use

package/dist/tools/tool-search.js

@@ -17,8 +17,9 @@ export function createToolSearchTool(controller) {
     return {
         name: "tool_search",
         readOnly: true,
+        effect: "read",
         description: 'Fetches full schema definitions for deferred tools so they can be called. ' +
-            'Deferred tools appear by name in <system-reminder> messages; their parameters are unknown ' +
+            'Deferred tools appear by name in hidden runtime reminders; their parameters are unknown ' +
             'until loaded. Use this tool with query "select:<name>[,<name>...]" to load specific tools, ' +
             'or with free-text keywords to search for relevant tools.',
         parameters: {

package/dist/tools/web-fetch.js

@@ -6,6 +6,7 @@ export function createWebFetchTool(approval) {
     return {
         name: "web_fetch",
         readOnly: true,
+        effect: "read",
         description: "Fetch and extract the contents of a specific URL using a remote web crawling service.",
         parameters: {
             type: "object",

package/dist/tools/web-search.js

@@ -7,6 +7,7 @@ export function createWebSearchTool() {
     return {
         name: "web_search",
         readOnly: true,
+        effect: "read",
         description: "Search the web using a remote search service and return current, structured results.",
         parameters: {
             type: "object",

package/dist/tools/write.js

@@ -10,6 +10,8 @@ import { formatDiagnosticBlocks } from "../lsp/index.js";
 export function createWriteTool(cwd, options = {}, approval, lsp) {
     return {
         name: "write",
+        effect: "write_direct",
+        requiresApproval: true,
         description: `Write a file to disk. Creates parent directories if needed.${options.refuseOverwrite ? " Will not overwrite existing files." : ""}`,
         parameters: {
             type: "object",

package/dist/tui/display-history.d.ts

@@ -1,4 +1,4 @@
-import type { ToolResultMetadata } from "../types.js";
+import type { ToolResultMetadata, TokenUsage } from "../types.js";
 export interface CompactionMeta {
     turns: number;
     messages: number;
@@ -20,15 +20,22 @@ export interface DisplayMessage {
     syntheticKind?: "ui_compact_card";
     hiddenCount?: number;
     compactionMeta?: CompactionMeta;
+    turnStartedAt?: number;
+    turnCompletedAt?: number;
+    turnUsage?: TokenUsage;
 }
 export interface DisplayToolCall {
     id: string;
     name: string;
     args: Record<string, any>;
+    rawArguments?: string;
+    streamingArgs?: boolean;
     status?: "pending" | "running" | "completed" | "error";
     result?: string;
     isError?: boolean;
     metadata?: ToolResultMetadata;
+    startedAt?: number;
+    completedAt?: number;
 }
 export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
 export declare function truncateText(value: string, maxChars: number): string;

package/dist/tui/markdown-inline.d.ts

@@ -0,0 +1,22 @@
+export interface MarkdownInlineSegment {
+    text: string;
+    color?: "text" | "textMuted" | "success" | "warning" | "secondary";
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+}
+type InlineToken = {
+    type?: string;
+    text?: string;
+    raw?: string;
+    href?: string;
+    tokens?: InlineToken[];
+};
+interface InlineStyle {
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+    color?: MarkdownInlineSegment["color"];
+}
+export declare function markdownInlineSegments(tokens: InlineToken[] | undefined, fallback?: string, style?: InlineStyle): MarkdownInlineSegment[];
+export {};