@oh-my-pi-zen/pi-utils 16.3.6-zen.1

package/dist/types/stream.d.ts

@@ -0,0 +1,68 @@
+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 line reader (`ConcatSink`) so chunk
+ * concatenation is O(n) and never triggers per-line string slicing of the
+ * accumulated buffer.
+ *
+ * @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/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
+ * `@oh-my-pi-zen/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/type-guards.d.ts

@@ -0,0 +1,3 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+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';
+/**
+ * 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';
+/**
+ * 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';
+/**
+ * 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';
+import type { AsciiGraph, AsciiConfig } from './types';
+/**
+ * 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';
+/**
+ * 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';
+/**
+ * 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;

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

@@ -0,0 +1,43 @@
+import type { Direction, AsciiEdge, AsciiGraph } from './types';
+export declare function getOpposite(d: Direction): Direction;
+/** Compare directions by value (not reference). */
+export declare function dirEquals(a: Direction, b: Direction): boolean;
+/**
+ * Determine 8-way direction from one coordinate to another.
+ * Uses the coordinate difference to pick one of 8 cardinal/ordinal directions.
+ */
+export declare function determineDirection(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): Direction;
+/**
+ * Determine preferred and alternative start/end directions for an edge.
+ * Returns [preferredStart, preferredEnd, alternativeStart, alternativeEnd].
+ *
+ * The edge routing tries both pairs and picks the shorter path.
+ * Direction selection depends on relative node positions and graph direction (LR vs TD).
+ */
+export declare function determineStartAndEndDir(edge: AsciiEdge, graphDirection: string): [Direction, Direction, Direction, Direction];
+/**
+ * Determine the path for an edge by trying two candidate routes (preferred + alternative)
+ * and picking the shorter one. Sets edge.path, edge.startDir, edge.endDir.
+ *
+ * When both A* paths fail (common for edges crossing subgraph boundaries), falls back
+ * to a direct path using the start/end points. This ensures edges always have a path
+ * for arrowhead rendering.
+ *
+ * Uses the effective direction for edge routing, respecting subgraph direction overrides
+ * when both source and target are in the same subgraph.
+ */
+export declare function determinePath(graph: AsciiGraph, edge: AsciiEdge): void;
+/**
+ * Find the best line segment in an edge's path to place a label on.
+ * Prefers vertical segments for TD/BT graphs and horizontal for LR/RL to avoid
+ * label collisions when multiple edges share initial segments.
+ * Falls back to the widest segment if none are suitable.
+ * Also increases the column width at the label position to fit the text.
+ */
+export declare function determineLabelLine(graph: AsciiGraph, edge: AsciiEdge): void;

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

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

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

@@ -0,0 +1,56 @@
+import type { GridCoord, DrawingCoord, Direction, AsciiGraph, AsciiNode, AsciiSubgraph } from './types';
+/**
+ * Convert a grid coordinate to a drawing (character) coordinate.
+ * Sums column widths up to the target column, and row heights up to the target row,
+ * then centers within the cell.
+ */
+export declare function gridToDrawingCoord(graph: AsciiGraph, c: GridCoord, dir?: Direction): DrawingCoord;
+/** Convert a path of grid coords to drawing coords. */
+export declare function lineToDrawing(graph: AsciiGraph, line: GridCoord[]): DrawingCoord[];
+/**
+ * Reserve a 3x3 block in the grid for a node.
+ * If the requested position is occupied, recursively shift by 4 grid units
+ * (in the perpendicular direction based on effective direction) until a free spot is found.
+ *
+ * @param effectiveDir - Optional direction override. If not provided, uses the node's
+ *                       effective direction (subgraph direction if in a subgraph with override,
+ *                       otherwise graph direction).
+ */
+export declare function reserveSpotInGrid(graph: AsciiGraph, node: AsciiNode, requested: GridCoord, effectiveDir?: 'LR' | 'TD'): GridCoord;
+/**
+ * Set column widths and row heights for a node's 3x3 grid block.
+ * Each node occupies 3 columns (border, content, border) and 3 rows.
+ * Uses shape-aware dimensions to properly size non-rectangular shapes.
+ */
+export declare function setColumnWidth(graph: AsciiGraph, node: AsciiNode): void;
+/** Ensure grid has width/height entries for all cells along an edge path. */
+export declare function increaseGridSizeForPath(graph: AsciiGraph, path: GridCoord[]): void;
+/**
+ * Get the innermost subgraph that directly contains this node.
+ * Returns null if node is not in any subgraph.
+ */
+export declare function getNodeSubgraph(graph: AsciiGraph, node: AsciiNode): AsciiSubgraph | null;
+/**
+ * Get the effective direction for a node's layout.
+ * Returns the subgraph's direction override if the node is in a subgraph with one,
+ * otherwise returns the graph-level direction.
+ */
+export declare function getEffectiveDirection(graph: AsciiGraph, node: AsciiNode): 'LR' | 'TD';
+export declare function calculateSubgraphBoundingBoxes(graph: AsciiGraph): void;
+/**
+ * Offset all drawing coordinates so subgraph borders don't go negative.
+ * If any subgraph has negative min coordinates, shift everything positive.
+ */
+export declare function offsetDrawingForSubgraphs(graph: AsciiGraph): void;
+/**
+ * createMapping performs the full grid layout:
+ * 1. Place root nodes on the grid
+ * 2. Place child nodes level by level
+ * 3. Compute column widths and row heights
+ * 4. Run A* pathfinding for all edges
+ * 5. Determine label placement
+ * 6. Convert grid coords → drawing coords
+ * 7. Generate node box drawings
+ * 8. Calculate subgraph bounding boxes
+ */
+export declare function createMapping(graph: AsciiGraph): void;

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

@@ -0,0 +1,65 @@
+import { detectColorMode, DEFAULT_ASCII_THEME } from './ansi';
+import type { AsciiTheme, ColorMode } from './types';
+import type { Direction } from '../types';
+export type { AsciiTheme, ColorMode };
+export { DEFAULT_ASCII_THEME, detectColorMode };
+export interface AsciiRenderOptions {
+    /** true = ASCII chars (+,-,|,>), false = Unicode box-drawing (┌,─,│,►). Default: false */
+    useAscii?: boolean;
+    /** Horizontal spacing between nodes. Default: 5 */
+    paddingX?: number;
+    /** Vertical spacing between nodes. Default: 5 */
+    paddingY?: number;
+    /** Padding inside node boxes. Default: 1 */
+    boxBorderPadding?: number;
+    /**
+     * Force the layout direction, overriding the direction parsed from the
+     * diagram source. Applies to the flowchart + state-diagram grid pipeline
+     * (sequence/class/ER/xychart renderers ignore it). Useful for re-fitting a
+     * wide `LR` graph into a narrow viewport by laying it out top-down.
+     * Default: undefined (use the source's own direction).
+     */
+    direction?: Direction;
+    /**
+     * Color mode for output.
+     * - 'none': No colors (plain text)
+     * - 'auto': Auto-detect (terminal ANSI capabilities, or HTML in browsers)
+     * - 'ansi16': 16-color ANSI
+     * - 'ansi256': 256-color xterm
+     * - 'truecolor': 24-bit RGB
+     * - 'html': HTML <span> tags with inline color styles (for browser rendering)
+     * Default: 'auto'
+     */
+    colorMode?: ColorMode | 'auto';
+    /** Theme colors for ASCII output. Uses default theme if not provided. */
+    theme?: Partial<AsciiTheme>;
+}
+/**
+ * Render Mermaid diagram text to an ASCII/Unicode string.
+ *
+ * Synchronous — no async layout engine needed (unlike the SVG renderer).
+ * Auto-detects diagram type from the header line and dispatches to
+ * the appropriate renderer.
+ *
+ * @param text - Mermaid source text (any supported diagram type)
+ * @param options - Rendering options
+ * @returns Multi-line ASCII/Unicode string
+ *
+ * @example
+ * ```ts
+ * const result = renderMermaidAscii(`
+ *   graph LR
+ *     A --> B --> C
+ * `, { useAscii: true })
+ *
+ * // Output:
+ * // +---+     +---+     +---+
+ * // |   |     |   |     |   |
+ * // | A |---->| B |---->| C |
+ * // |   |     |   |     |   |
+ * // +---+     +---+     +---+
+ * ```
+ */
+export declare function renderMermaidASCII(text: string, options?: AsciiRenderOptions): string;
+/** Lowercase alias kept as the public name used by the pi-utils wrapper. */
+export declare const renderMermaidAscii: typeof renderMermaidASCII;

package/dist/types/vendor/mermaid-ascii/ascii/multiline-utils.d.ts

@@ -0,0 +1,27 @@
+import type { Canvas } from './types';
+/**
+ * Split a label into lines.
+ * Labels are already normalized by parsers (br tags → \n).
+ */
+export declare function splitLines(label: string): string[];
+/**
+ * Get the maximum line width for sizing calculations.
+ * Used to determine column widths for multi-line labels.
+ */
+export declare function maxLineWidth(label: string): number;
+/**
+ * Get the number of lines for height calculations.
+ * Used to determine row heights for multi-line labels.
+ */
+export declare function lineCount(label: string): number;
+/**
+ * Draw multi-line text centered at (cx, cy).
+ * Expands vertically from the center point.
+ * Each line is horizontally centered independently.
+ */
+export declare function drawMultilineTextCentered(canvas: Canvas, label: string, cx: number, cy: number): void;
+/**
+ * Draw multi-line text left-aligned starting at (x, y).
+ * Each subsequent line is placed one row below.
+ */
+export declare function drawMultilineTextLeft(canvas: Canvas, label: string, x: number, y: number): void;