@linxiraos/pi-utils 1.0.0

package/dist/types/stream.d.ts

@@ -0,0 +1,67 @@
+export declare function readLines(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<Uint8Array>;
+export declare function readJsonl<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<T>;
+/**
+ * Stream parsed JSON objects from SSE `data:` lines.
+ *
+ * Thin wrapper over {@link readSseEvents}: yields one parsed JSON value per
+ * dispatched SSE event, skipping events with empty `data` and stopping at the
+ * OpenAI-style `[DONE]` sentinel. If your consumer doesn't care about `event:`
+ * names or doesn't need a custom parse step, use this; otherwise call
+ * `readSseEvents` directly.
+ *
+ * @example
+ * ```ts
+ * for await (const obj of readSseJson(response.body!)) {
+ *   console.log(obj);
+ * }
+ * ```
+ */
+export type SseEventObserver = (event: ServerSentEvent) => void;
+export declare function readSseJson<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal, onEvent?: SseEventObserver): AsyncGenerator<T>;
+/**
+ * A single Server-Sent Event dispatched on a blank-line boundary.
+ *
+ * - `event` is the value of the most recent `event:` field, or `null` if none.
+ * - `data` is the concatenation (joined by `\n`) of every `data:` field in the
+ *   event, exactly as required by the SSE spec.
+ * - `raw` is the list of decoded non-empty lines that made up the event,
+ *   preserved for diagnostic context (error reporting, debugging). The
+ *   dispatching blank line is not included.
+ */
+export interface ServerSentEvent {
+    event: string | null;
+    data: string;
+    raw: string[];
+}
+/**
+ * Stream raw Server-Sent Events from an HTTP response body.
+ *
+ * Yields one `ServerSentEvent` per blank-line dispatch. The consumer is
+ * responsible for parsing `data` (e.g. JSON, plain text, error envelope).
+ * Use `readSseJson` instead when every event is a single `data:` JSON object
+ * and you don't need access to the `event:` field.
+ *
+ * Internally backed by a Buffer-based reader (`ConcatSink`) that batches all
+ * complete lines in each source chunk into one UTF-8 decode.
+ *
+ * @example
+ * ```ts
+ * for await (const sse of readSseEvents(response.body!)) {
+ *   if (sse.event === "ping") continue;
+ *   const obj = JSON.parse(sse.data);
+ * }
+ * ```
+ */
+export declare function readSseEvents(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<ServerSentEvent>;
+/**
+ * Parse a complete JSONL string, skipping malformed lines instead of throwing.
+ *
+ * Uses `Bun.JSONL.parseChunk` internally. On parse errors, the malformed
+ * region is skipped up to the next newline and parsing continues.
+ *
+ * @example
+ * ```ts
+ * const entries = parseJsonlLenient<MyType>(fileContents);
+ * ```
+ */
+export declare function parseJsonlLenient<T>(buffer: string): T[];

package/dist/types/tab-spacing.d.ts

@@ -0,0 +1,24 @@
+export declare const MIN_TAB_WIDTH = 1;
+export declare const MAX_TAB_WIDTH = 16;
+export declare const DEFAULT_TAB_WIDTH = 3;
+/**
+ * `.editorconfig`-derived formatting options for an LSP `textDocument/formatting` request.
+ *
+ * Both fields are absent when the resolved `.editorconfig` chain does not pin them, so callers
+ * can layer their own fallbacks (content sniffing, project defaults) underneath. Returned values
+ * are clamped to {@link MIN_TAB_WIDTH}..{@link MAX_TAB_WIDTH}.
+ */
+export interface EditorConfigFormatting {
+    /** Effective indent width in columns, from `indent_size` or `tab_width`. */
+    tabSize?: number;
+    /** `true` for `indent_style = space`, `false` for `indent_style = tab` (or `indent_size = tab`). */
+    insertSpaces?: boolean;
+}
+/**
+ * Resolve `.editorconfig` formatting hints for `file` without falling back to any default.
+ *
+ * Used by the LSP format-on-write path so a missing `.editorconfig` declaration falls through
+ * to caller-provided defaults instead of clobbering the file with the renderer's
+ * display tab width (issue #2329).
+ */
+export declare function getEditorConfigFormatting(file?: string | null, projectDir?: string | null): EditorConfigFormatting;

package/dist/types/temp.d.ts

@@ -0,0 +1,17 @@
+export declare class TempDir {
+    #private;
+    private constructor();
+    static createSync(prefix?: string): TempDir;
+    static create(prefix?: string): Promise<TempDir>;
+    path(): string;
+    absolute(): string;
+    remove(): Promise<void>;
+    removeSync(): void;
+    toString(): string;
+    join(...paths: string[]): string;
+    [Symbol.asyncDispose](): Promise<void>;
+    [Symbol.dispose](): void;
+}
+/** Removes a path recursively, retrying transient Windows deletion failures. */
+export declare function removeWithRetries(target: string): Promise<void>;
+export declare function removeSyncWithRetries(target: string): void;

package/dist/types/template.d.ts

@@ -0,0 +1,62 @@
+/** Behavior-compatible reimplementation of handlebars' used surface. */
+/** Values accepted as registered partial templates. */
+export type Template = string | TemplateDelegate;
+/** A compiled template function. */
+export type TemplateDelegate<T = unknown> = (context?: T, options?: RuntimeOptions) => string;
+/** Runtime options accepted by compiled templates. */
+export interface RuntimeOptions {
+    data?: Record<string, unknown>;
+    helpers?: Record<string, HelperDelegate>;
+    partials?: Record<string, Template>;
+}
+/** Options passed as the final argument to helpers. */
+export interface HelperOptions {
+    name: string;
+    hash: Record<string, unknown>;
+    data: Record<string, unknown>;
+    fn: (context?: unknown, options?: {
+        data?: Record<string, unknown>;
+    }) => string;
+    inverse: (context?: unknown, options?: {
+        data?: Record<string, unknown>;
+    }) => string;
+    lookupProperty: (parent: unknown, propertyName: string) => unknown;
+}
+/** A template helper function. */
+export type HelperDelegate = {
+    bivarianceHack(this: unknown, ...args: unknown[]): unknown;
+}["bivarianceHack"];
+/** Template compilation behavior. */
+export interface CompileOptions {
+    noEscape?: boolean;
+    strict?: boolean;
+}
+/** A string that bypasses HTML escaping when interpolated. */
+export declare class SafeString {
+    #private;
+    constructor(value: unknown);
+    /** Return the unescaped string value. */
+    toString(): string;
+    /** Return the unescaped primitive value. */
+    toHTML(): string;
+}
+/** Escape a value with Handlebars' HTML entity set. */
+export declare function escapeExpression(value: unknown): string;
+/** Register a helper for subsequently compiled templates. */
+export declare function registerHelper(name: string, helper: HelperDelegate): void;
+/** Register a partial for subsequently rendered templates. */
+export declare function registerPartial(name: string, partial: Template): void;
+/** Compile a template into a reusable rendering function. */
+export declare function compile<T = unknown>(source: string, options?: CompileOptions): TemplateDelegate<T>;
+/** Create an isolated template engine with its own helper and partial registries. */
+export declare function create(): TemplateEngine;
+/** Isolated template compiler and registry. */
+export declare class TemplateEngine {
+    #private;
+    /** Register a helper in this engine. */
+    registerHelper(name: string, helper: HelperDelegate): void;
+    /** Register a partial in this engine. */
+    registerPartial(name: string, partial: Template): void;
+    /** Compile a template using this engine's registries. */
+    compile<T = unknown>(source: string, options?: CompileOptions): TemplateDelegate<T>;
+}

package/dist/types/timing-buffer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared contract between the {@link module-timer} preload and {@link logger}'s
+ * timing tree. Kept in its own dependency-free module so the preload can import
+ * it without pulling in winston (via logger) and the logger can drain the buffer
+ * without importing the Bun-plugin preload.
+ */
+export interface ModuleLoadEvent {
+    /** Absolute or Bun-resolved module path. */
+    path: string;
+    /** `performance.now()` timestamp captured at Bun `onLoad` entry. */
+    start: number;
+    /** Inclusive module window: `onLoad` entry → appended final marker. */
+    durationMs: number;
+    /** Own top-level body / TLA time: prepended body marker → appended final marker. */
+    bodyMs?: number;
+    /** Resolved static children imported by this module. */
+    imports: string[];
+}
+/** The append-only buffer the preload pushes into (created on first access). */
+export declare function moduleLoadBuffer(): ModuleLoadEvent[];
+/** Drain and return all buffered events, leaving the buffer empty. */
+export declare function drainModuleLoadEvents(): ModuleLoadEvent[];

package/dist/types/tls-fetch.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `fetch`-compatible function. Accepts any callable matching the standard
+ * fetch signature; `preconnect` is optional because non-Bun runtimes
+ * (browsers, test mocks) won't expose it.
+ */
+export type FetchImpl = ((input: string | URL | Request, init?: RequestInit) => Promise<Response>) & {
+    preconnect?: typeof globalThis.fetch.preconnect;
+};
+/**
+ * `NODE_EXTRA_CA_CERTS` was set but unusable (path does not exist). This is
+ * a config/contract error, not a transient transport fault — it is never
+ * retried.
+ */
+export declare class ExtraCaError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Test seam: drop the cached PEM so a follow-up call re-reads the env. */
+export declare function __resetExtraCaCache(): void;
+/**
+ * Wrap `fetchImpl` so every call honours `NODE_EXTRA_CA_CERTS`. Idempotent:
+ * a fetch already wrapped is returned unchanged so repeated composition
+ * (Anthropic auth-retry replays, request-debug fan-out) never stacks
+ * wrappers. When the env var is unset the original fetch is returned, so
+ * default deployments pay nothing.
+ */
+export declare function wrapFetchForExtraCa(fetchImpl: FetchImpl): FetchImpl;
+/**
+ * Convenience for options-bag composition (e.g. the stream-entry path in
+ * `@linxiraos/pi-ai`'s `stream.ts`, which mirrors `withRequestDebugFetch` so
+ * the proxy/debug/extra-CA wrappers compose uniformly). No-op when the env
+ * var is unset.
+ */
+export declare function withExtraCaFetch<T extends {
+    fetch?: FetchImpl;
+} | undefined>(options: T): T;

package/dist/types/turndown/gfm.d.ts

@@ -0,0 +1,11 @@
+import type { TurndownPlugin } from "./types.js";
+/** Install GitHub fenced code blocks selected by `highlight-source-*` wrappers. */
+export declare const highlightedCodeBlock: TurndownPlugin;
+/** Install GFM strikethrough conversion. */
+export declare const strikethrough: TurndownPlugin;
+/** Install GFM task-list checkbox conversion. */
+export declare const taskListItems: TurndownPlugin;
+/** Install GFM table conversion for tables with a heading row. */
+export declare const tables: TurndownPlugin;
+/** Install every GFM rule used by the coding agent. */
+export declare const gfm: TurndownPlugin;

package/dist/types/turndown/html.d.ts

@@ -0,0 +1,5 @@
+import type { TurndownNode } from "./types.js";
+/** Parse an HTML fragment into the small DOM subset needed by Turndown. */
+export declare function parseHtmlFragment(html: string): TurndownNode;
+/** Serialize a standards-shaped or internal HTML node. */
+export declare function serializeNode(node: TurndownNode): string;

package/dist/types/turndown/service.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedTurndownOptions, RuleFilter, TurndownNode, TurndownOptions, TurndownPlugin, TurndownRule } from "./types.js";
+/** Convert HTML fragments to Markdown with extensible Turndown-compatible rules. */
+export default class TurndownService {
+    #private;
+    readonly options: ResolvedTurndownOptions;
+    constructor(options?: TurndownOptions);
+    /** Install a highest-priority named conversion rule. */
+    addRule(key: string, rule: TurndownRule): this;
+    /** Preserve matching elements as HTML when no custom rule handles them. */
+    keep(filter: RuleFilter): this;
+    /** Drop matching elements and all of their converted content. */
+    remove(filter: RuleFilter): this;
+    /** Install one plugin or an ordered list of plugins. */
+    use(plugin: TurndownPlugin | readonly TurndownPlugin[]): this;
+    /** Escape Markdown punctuation using Turndown's public escaping rules. */
+    escape(text: string): string;
+    /** Convert an HTML string or standards-shaped DOM node to Markdown. */
+    turndown(input: string | TurndownNode): string;
+    /** Convert only a node's children within the active conversion. */
+    convertChildren(node: TurndownNode): string;
+}

package/dist/types/turndown/types.d.ts

@@ -0,0 +1,70 @@
+/** Behavior-compatible reimplementation of turndown's used surface. */
+/** A DOM-shaped node accepted by conversion rules. */
+export interface TurndownNode {
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly parentNode: TurndownNode | null;
+    readonly childNodes: ArrayLike<TurndownNode>;
+    readonly children: ArrayLike<TurndownNode>;
+    readonly firstChild: TurndownNode | null;
+    readonly lastChild: TurndownNode | null;
+    readonly nextSibling: TurndownNode | null;
+    readonly previousSibling: TurndownNode | null;
+    readonly textContent: string | null;
+    readonly outerHTML?: string;
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+}
+/** Options supported by the HTML-to-Markdown converter. */
+export interface TurndownOptions {
+    headingStyle?: "setext" | "atx";
+    hr?: string;
+    bulletListMarker?: "*" | "-" | "+";
+    codeBlockStyle?: "indented" | "fenced";
+    fence?: string;
+    emDelimiter?: "_" | "*";
+    strongDelimiter?: "**" | "__";
+    linkStyle?: "inlined" | "referenced";
+    linkReferenceStyle?: "full" | "collapsed" | "shortcut";
+    preformattedCode?: boolean;
+    blankReplacement?: ReplacementFunction;
+    keepReplacement?: ReplacementFunction;
+    defaultReplacement?: ReplacementFunction;
+}
+/** Fully resolved options passed to replacement callbacks. */
+export interface ResolvedTurndownOptions {
+    headingStyle: "setext" | "atx";
+    hr: string;
+    bulletListMarker: "*" | "-" | "+";
+    codeBlockStyle: "indented" | "fenced";
+    fence: string;
+    emDelimiter: "_" | "*";
+    strongDelimiter: "**" | "__";
+    linkStyle: "inlined" | "referenced";
+    linkReferenceStyle: "full" | "collapsed" | "shortcut";
+    preformattedCode: boolean;
+    blankReplacement?: ReplacementFunction;
+    keepReplacement?: ReplacementFunction;
+    defaultReplacement?: ReplacementFunction;
+}
+/** A tag name, list of tag names, or predicate selecting nodes for a rule. */
+export type RuleFilter = string | readonly string[] | ((node: TurndownNode, options: ResolvedTurndownOptions) => boolean);
+/** Produces Markdown for a matched node and its already-converted children. */
+export type ReplacementFunction = (content: string, node: TurndownNode, options: ResolvedTurndownOptions) => string;
+/** A named conversion rule accepted by `addRule`. */
+export interface TurndownRule {
+    filter: RuleFilter;
+    replacement: ReplacementFunction;
+}
+/** A plugin that installs one or more conversion rules. */
+export type TurndownPlugin = (service: TurndownServiceLike) => void;
+/** Structural service surface available to plugins. */
+export interface TurndownServiceLike {
+    readonly options: ResolvedTurndownOptions;
+    addRule(key: string, rule: TurndownRule): this;
+    convertChildren(node: TurndownNode): string;
+    keep(filter: RuleFilter): this;
+    remove(filter: RuleFilter): this;
+    turndown(input: string | TurndownNode): string;
+    escape(text: string): string;
+}

package/dist/types/turndown.d.ts

@@ -0,0 +1,4 @@
+/** Behavior-compatible reimplementation of turndown's used surface. */
+export * from "./turndown/gfm.js";
+export { default, default as TurndownService } from "./turndown/service.js";
+export * from "./turndown/types.js";

package/dist/types/type-guards.d.ts

@@ -0,0 +1,5 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Reads an own string-valued property without invoking accessors. */
+export declare function stringProperty(value: object, key: string): string | undefined;
+export declare function asRecord(value: unknown): Record<string, unknown> | null;
+export declare function toError(value: unknown): Error;

package/dist/types/vendor/mermaid-ascii/ascii/ansi.d.ts

@@ -0,0 +1,41 @@
+import type { CharRole, AsciiTheme, ColorMode } from './types.js';
+/**
+ * Default ASCII theme derived from the SVG renderer's color palette.
+ * Uses the same mixing ratios to maintain visual consistency.
+ */
+export declare const DEFAULT_ASCII_THEME: AsciiTheme;
+/**
+ * Detect the best color mode for the current environment.
+ *
+ * Terminal detection order:
+ * 1. COLORTERM=truecolor or COLORTERM=24bit → truecolor
+ * 2. TERM contains "256color" → ansi256
+ * 3. TERM is set and not "dumb" → ansi16
+ *
+ * Browser: returns 'html' (uses <span> tags with inline styles).
+ * Unknown/piped: returns 'none'.
+ */
+export declare function detectColorMode(): ColorMode;
+/**
+ * Generate the ANSI escape sequence for a role color.
+ */
+export declare function getAnsiColor(role: CharRole, theme: AsciiTheme, mode: ColorMode): string;
+/**
+ * Get the ANSI reset sequence.
+ */
+export declare function getAnsiReset(mode: ColorMode): string;
+/**
+ * Wrap a character with ANSI color codes based on its role.
+ */
+export declare function colorizeChar(char: string, role: CharRole | null, theme: AsciiTheme, mode: ColorMode): string;
+/**
+ * Colorize an entire line efficiently by grouping consecutive same-role characters.
+ * This reduces the number of escape sequences (ANSI) or span tags (HTML) in the output.
+ */
+export declare function colorizeLine(chars: string[], roles: (CharRole | null)[], theme: AsciiTheme, mode: ColorMode): string;
+/**
+ * Colorize a text string with a direct hex color.
+ * Used by renderers that need per-cell color control (e.g. multi-series xychart).
+ * Handles all output modes: ANSI (16/256/truecolor) and HTML.
+ */
+export declare function colorizeText(text: string, hex: string, mode: ColorMode): string;

package/dist/types/vendor/mermaid-ascii/ascii/canvas.d.ts

@@ -0,0 +1,89 @@
+import type { Canvas, DrawingCoord, RoleCanvas, CharRole, AsciiTheme, ColorMode } from './types.js';
+/**
+ * Create a blank canvas filled with spaces.
+ * Dimensions are inclusive: mkCanvas(3, 2) creates a 4x3 grid (indices 0..3, 0..2).
+ */
+export declare function mkCanvas(x: number, y: number): Canvas;
+/** Create a blank canvas with the same dimensions as the given canvas. */
+export declare function copyCanvas(source: Canvas): Canvas;
+/**
+ * Create a blank role canvas filled with nulls.
+ * Same dimensions as mkCanvas — column-major, roleCanvas[x][y].
+ */
+export declare function mkRoleCanvas(x: number, y: number): RoleCanvas;
+/** Create a blank role canvas with the same dimensions as the given role canvas. */
+export declare function copyRoleCanvas(source: RoleCanvas): RoleCanvas;
+/**
+ * Grow the role canvas to fit at least (newX, newY), preserving existing roles.
+ * Mutates the role canvas in place and returns it.
+ */
+export declare function increaseRoleCanvasSize(roleCanvas: RoleCanvas, newX: number, newY: number): RoleCanvas;
+/**
+ * Set a role at a specific coordinate.
+ * Expands the role canvas if necessary.
+ */
+export declare function setRole(roleCanvas: RoleCanvas, x: number, y: number, role: CharRole): void;
+/**
+ * Merge role canvases — same logic as mergeCanvases but for roles.
+ * Non-null roles in overlays overwrite null roles in base.
+ */
+export declare function mergeRoleCanvases(base: RoleCanvas, offset: DrawingCoord, ...overlays: RoleCanvas[]): RoleCanvas;
+/** Returns [maxX, maxY] — the highest valid indices in each dimension. */
+export declare function getCanvasSize(canvas: Canvas): [number, number];
+/**
+ * Grow the canvas to fit at least (newX, newY), preserving existing content.
+ * Mutates the canvas in place and returns it.
+ */
+export declare function increaseSize(canvas: Canvas, newX: number, newY: number): Canvas;
+export declare function isJunctionChar(c: string): boolean;
+export declare function mergeJunctions(c1: string, c2: string): string;
+/**
+ * Merge overlay canvases onto a base canvas at the given offset.
+ * Non-space characters in overlays overwrite the base.
+ * When both characters are Unicode junction chars, they're merged intelligently.
+ */
+export declare function mergeCanvases(base: Canvas, offset: DrawingCoord, useAscii: boolean, ...overlays: Canvas[]): Canvas;
+/** Options for converting canvas to string with optional coloring. */
+export interface CanvasToStringOptions {
+    /** Role canvas for applying colors. If not provided, output is plain text. */
+    roleCanvas?: RoleCanvas;
+    /** Color mode for terminal output. Default: 'none' */
+    colorMode?: ColorMode;
+    /** Theme colors for ASCII output. Uses default theme if not provided. */
+    theme?: AsciiTheme;
+}
+/**
+ * Convert the canvas to a multi-line string (row by row, left to right).
+ * Optionally applies ANSI color codes based on character roles.
+ */
+export declare function canvasToString(canvas: Canvas, options?: CanvasToStringOptions): string;
+/**
+ * Flip the canvas vertically (mirror across the horizontal center).
+ * Reverses row order within each column and remaps directional characters
+ * (arrows, corners, junctions) so they point the correct way after flip.
+ *
+ * Used to transform a TD-rendered canvas into BT output.
+ * Mutates the canvas in place and returns it.
+ */
+export declare function flipCanvasVertically(canvas: Canvas): Canvas;
+/**
+ * Flip the role canvas vertically to match flipCanvasVertically.
+ * Mutates the role canvas in place and returns it.
+ */
+export declare function flipRoleCanvasVertically(roleCanvas: RoleCanvas): RoleCanvas;
+/**
+ * Draw text string onto the canvas starting at the given coordinate.
+ * By default, preserves existing non-space characters (labels don't overwrite each other).
+ * Set forceOverwrite=true to always overwrite (for box content).
+ */
+export declare function drawText(canvas: Canvas, start: DrawingCoord, text: string, forceOverwrite?: boolean): void;
+/**
+ * Set the canvas size to fit all grid columns and rows.
+ * Called after layout to ensure the canvas covers the full drawing area.
+ */
+export declare function setCanvasSizeToGrid(canvas: Canvas, columnWidth: Map<number, number>, rowHeight: Map<number, number>): void;
+/**
+ * Set the role canvas size to match the grid dimensions.
+ * Should be called alongside setCanvasSizeToGrid.
+ */
+export declare function setRoleCanvasSizeToGrid(roleCanvas: RoleCanvas, columnWidth: Map<number, number>, rowHeight: Map<number, number>): void;

package/dist/types/vendor/mermaid-ascii/ascii/class-diagram.d.ts

@@ -0,0 +1,7 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types.js';
+/**
+ * Render a Mermaid class diagram to ASCII/Unicode text.
+ *
+ * Pipeline: parse → build boxes → level-based layout → draw boxes → draw relationships → string.
+ */
+export declare function renderClassAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string;

package/dist/types/vendor/mermaid-ascii/ascii/converter.d.ts

@@ -0,0 +1,12 @@
+import type { MermaidGraph } from '../types.js';
+import type { AsciiGraph, AsciiConfig } from './types.js';
+/**
+ * Convert a parsed MermaidGraph into an AsciiGraph ready for grid layout.
+ *
+ * Key mappings:
+ * - MermaidGraph.nodes (Map) → ordered AsciiNode[] preserving insertion order
+ * - MermaidGraph.edges → AsciiEdge[] with resolved node references
+ * - MermaidGraph.subgraphs → AsciiSubgraph[] with parent/child tree
+ * - Node labels are used as display names (not raw IDs)
+ */
+export declare function convertToAsciiGraph(parsed: MermaidGraph, config: AsciiConfig): AsciiGraph;

package/dist/types/vendor/mermaid-ascii/ascii/draw.d.ts

@@ -0,0 +1,66 @@
+import type { Canvas, DrawingCoord, AsciiGraph, AsciiNode, AsciiEdge, AsciiSubgraph, AsciiEdgeStyle } from './types.js';
+/**
+ * Draw a node using its shape type.
+ * Returns a standalone canvas containing the rendered shape.
+ *
+ * For basic shapes (rectangle, rounded), uses grid-determined dimensions
+ * to ensure consistent sizing across nodes in the same column.
+ * For special shapes (diamond, circle, state pseudo-states, etc.),
+ * uses shape-specific dimension calculation but centers the content
+ * within the grid cell dimensions to ensure proper vertical alignment.
+ */
+export declare function drawNode(node: AsciiNode, graph: AsciiGraph): Canvas;
+/**
+ * Draw a node box with centered label text.
+ * Returns a standalone canvas containing just the box.
+ * Box size is determined by the grid column/row sizes for the node's position.
+ */
+export declare function drawBox(node: AsciiNode, graph: AsciiGraph): Canvas;
+/**
+ * Draw a multi-section box with horizontal dividers between sections.
+ * Used by class diagrams (header | attributes | methods) and ER diagrams (header | attributes).
+ * Each section is an array of text lines to render left-aligned with padding.
+ *
+ * @param sections - Array of sections, each section is an array of text lines
+ * @param useAscii - true for ASCII chars, false for Unicode box-drawing
+ * @param padding - horizontal padding inside the box (default 1)
+ * @returns A standalone Canvas containing the multi-section box
+ */
+export declare function drawMultiBox(sections: string[][], useAscii: boolean, padding?: number): Canvas;
+/**
+ * Draw a line between two drawing coordinates using orthogonal Manhattan routing.
+ * Returns the list of coordinates that were drawn on.
+ * offsetFrom/offsetTo control how many cells to skip at the start/end.
+ *
+ * All lines use 90° bends only - no diagonal lines are produced.
+ * For diagonal directions, uses horizontal-first routing (draws horizontal
+ * segment, then vertical segment).
+ */
+export declare function drawLine(canvas: Canvas, from: DrawingCoord, to: DrawingCoord, offsetFrom: number, offsetTo: number, useAscii: boolean, style?: AsciiEdgeStyle): DrawingCoord[];
+/**
+ * Draw a complete arrow (edge) between two nodes.
+ * Returns 6 separate canvases for layered compositing:
+ * [path, boxStart, arrowHeadEnd, arrowHeadStart, corners, label]
+ *
+ * Supports bidirectional arrows via edge.hasArrowStart and edge.hasArrowEnd.
+ */
+export declare function drawArrow(graph: AsciiGraph, edge: AsciiEdge): [Canvas, Canvas, Canvas, Canvas, Canvas, Canvas];
+/** Draw a subgraph border rectangle. */
+export declare function drawSubgraphBox(sg: AsciiSubgraph, graph: AsciiGraph): Canvas;
+/** Draw a subgraph label centered in its header area. Supports multi-line labels. */
+export declare function drawSubgraphLabel(sg: AsciiSubgraph, graph: AsciiGraph): [Canvas, DrawingCoord];
+/**
+ * Main draw function — renders the entire graph onto the canvas.
+ * Drawing order matters for correct layering:
+ * 1. Subgraph borders (bottom layer)
+ * 2. Node boxes
+ * 3. Edge paths (lines)
+ * 4. Edge corners
+ * 5. Arrowheads
+ * 6. Box-start junctions
+ * 7. Edge labels
+ * 8. Subgraph labels (top layer)
+ *
+ * Also fills the roleCanvas with character roles for colored output.
+ */
+export declare function drawGraph(graph: AsciiGraph): Canvas;

package/dist/types/vendor/mermaid-ascii/ascii/edge-bundling.d.ts

@@ -0,0 +1,48 @@
+import type { AsciiGraph, EdgeBundle, GridCoord } from './types.js';
+/**
+ * Analyze graph edges and create bundles for parallel links.
+ *
+ * Groups edges by:
+ * - Fan-in: Multiple edges sharing the same target (A & B --> C)
+ * - Fan-out: Multiple edges sharing the same source (A --> B & C)
+ *
+ * Only creates bundles when:
+ * - Graph direction is TD (top-down) - LR routing handles merging naturally
+ * - 2+ edges share the endpoint
+ * - All edges have the same style (solid/dotted/thick)
+ * - None of the edges have labels (labels would overlap at junction)
+ * - Edges are not self-loops
+ *
+ * @returns Array of bundles. Each edge can belong to at most one bundle.
+ */
+export declare function analyzeEdgeBundles(graph: AsciiGraph): EdgeBundle[];
+/**
+ * Calculate the optimal junction point for a bundle.
+ *
+ * For fan-in (A & B --> C):
+ *   - Junction is placed between the sources and the target
+ *   - In TD: above the target, horizontally centered between sources
+ *   - In LR: left of the target, vertically centered between sources
+ *
+ * For fan-out (A --> B & C):
+ *   - Junction is placed between the source and the targets
+ *   - In TD: below the source, horizontally centered between targets
+ *   - In LR: right of the source, vertically centered between targets
+ */
+export declare function calculateJunctionPoint(graph: AsciiGraph, bundle: EdgeBundle): GridCoord;
+/**
+ * Route all edges in a bundle through the junction point.
+ *
+ * For fan-in bundles:
+ *   1. Route each source → junction (stored in edge.pathToJunction)
+ *   2. Route junction → target (stored in bundle.sharedPath)
+ *
+ * For fan-out bundles:
+ *   1. Route source → junction (stored in bundle.sharedPath)
+ *   2. Route junction → each target (stored in edge.pathToJunction)
+ */
+export declare function routeBundledEdges(graph: AsciiGraph, bundle: EdgeBundle): void;
+/**
+ * Process all bundles in a graph: calculate junction points and route edges.
+ */
+export declare function processBundles(graph: AsciiGraph): void;