@linxiraos/pi-utils 1.1.20 → 1.1.23

package/src/stderr-guard.ts

@@ -2,20 +2,17 @@
  * Terminal stderr guard: keeps unmanaged fd-2 writes off the terminal while a
  * TUI owns the viewport.
  *
- * On macOS, runtime diagnostics are written by the platform directly to file
- * descriptor 2 at arbitrary times — e.g. libmalloc's "MallocStackLogging:
- * can't turn off malloc stack logging because it was not enabled" when the OS
- * broadcasts a memory-diagnostic event to long-lived processes. Those bytes
- * bypass the renderer and paint straight into the viewport. Stripping the
- * MallocStackLogging* env vars (cli.ts) only protects child processes; it
- * cannot stop libmalloc inside THIS process from logging.
+ * Native runtimes and libraries can write directly to file descriptor 2 at
+ * arbitrary times. Examples include macOS libmalloc diagnostics and Bun HTTP
+ * decompression diagnostics on Linux. Those bytes bypass the renderer and
+ * paint straight into the viewport.
  *
- * Fix (mirrors openai/codex#24459): while the TUI owns the terminal, dup fd 2
- * aside and dup2 a redirect target over it; restore the saved fd whenever
- * terminal ownership is released (external editor, Ctrl+Z suspend, shutdown,
- * crash restore). Unlike codex we redirect to the omp log file — not
- * /dev/null — so the diagnostics stay greppable and Bun native-crash reports
- * (which abort before any JS cleanup can restore fd 2) are preserved.
+ * While the TUI owns the terminal, dup fd 2 aside and dup2 a redirect target
+ * over it; restore the saved fd whenever terminal ownership is released
+ * (external editor, Ctrl+Z suspend, shutdown, crash restore). This mirrors
+ * openai/codex#24459, but redirects to the omp log file instead of /dev/null
+ * so diagnostics stay greppable and Bun native-crash reports (which abort
+ * before any JS cleanup can restore fd 2) are preserved.
  *
  * Only dup/dup2 go through bun:ffi. fcntl is deliberately avoided: it is
  * variadic, and the arm64-darwin ABI passes variadic arguments on the stack,
@@ -79,35 +76,41 @@ function stderrSharesStdoutTerminal(): boolean {
 /** Saved dup of the real stderr while suppression is active, else null. */
 let savedStderrFd: number | null = null;
 
+/** Newest log file the guard knows about; see {@link setStderrRedirectTarget}. */
+let redirectTarget: string | null = null;
+
 export interface SuppressTerminalStderrOptions {
-	/** Redirect target path; defaults to today's omp log file, then /dev/null. */
+	/**
+	 * Redirect target path; defaults to the log file the rotating sink last
+	 * reported (see {@link setStderrRedirectTarget}), then today's omp log
+	 * file, then /dev/null.
+	 */
 	redirectPath?: string;
-	/** Bypass the macOS + same-terminal gate. Tests only. */
+	/** Bypass the same-terminal gate. Tests only. */
 	force?: boolean;
 }
 
 /**
  * Redirect fd 2 away from the terminal while the TUI owns the viewport.
  * Returns true when suppression is (already) active. No-op — returning
- * false — off macOS, when stderr does not target the stdout terminal, or
- * when the libc fd ops are unavailable.
+ * false — when stderr does not target the stdout terminal or when libc fd
+ * operations are unavailable.
  */
 export function suppressTerminalStderr(options?: SuppressTerminalStderrOptions): boolean {
 	if (savedStderrFd !== null) return true;
-	if (!options?.force && (process.platform !== "darwin" || !stderrSharesStdoutTerminal())) {
-		return false;
-	}
+	if (!options?.force && !stderrSharesStdoutTerminal()) return false;
 	const libc = libcFdOps();
 	if (!libc) return false;
 
 	let redirectFd: number;
 	try {
-		const redirectPath = options?.redirectPath ?? getLogPath();
+		const redirectPath = options?.redirectPath ?? redirectTarget ?? getLogPath();
 		// getLogsDir() only computes the path; the logger creates it lazily, so
 		// on a fresh profile ~/.zeta/logs may not exist yet. Create it here so
 		// diagnostics land in the log instead of falling through to /dev/null.
 		fs.mkdirSync(path.dirname(redirectPath), { recursive: true });
 		redirectFd = fs.openSync(redirectPath, "a");
+		redirectTarget = redirectPath;
 	} catch {
 		try {
 			redirectFd = fs.openSync("/dev/null", "w");
@@ -131,6 +134,35 @@ export function suppressTerminalStderr(options?: SuppressTerminalStderrOptions):
 	return true;
 }
 
+/**
+ * Point fd 2 at `logPath`, the log file the rotating sink is currently
+ * writing.
+ *
+ * The logger calls this on every sink rotation. Without it fd 2 keeps the
+ * descriptor opened at TUI start, so after local midnight raw stderr — this
+ * process's and every child that inherited fd 2 — keeps landing in the
+ * previous day's file, which the sink eventually prunes out from under it.
+ *
+ * The path is recorded even while suppression is inactive, so a later
+ * {@link suppressTerminalStderr} redirects to the live file instead of
+ * re-deriving a dated name. Best-effort: if the new file cannot be opened,
+ * fd 2 keeps its current target.
+ */
+export function setStderrRedirectTarget(logPath: string): void {
+	redirectTarget = logPath;
+	if (savedStderrFd === null) return;
+	const libc = libcFdOps();
+	if (!libc) return;
+	let redirectFd: number;
+	try {
+		redirectFd = fs.openSync(logPath, "a");
+	} catch {
+		return;
+	}
+	libc.dup2(redirectFd, STDERR_FILENO);
+	fs.closeSync(redirectFd);
+}
+
 /**
  * Re-point fd 2 at the saved terminal stderr. Safe to call unconditionally:
  * no-op when suppression is not active. Called at every terminal-ownership

package/src/stream.ts

@@ -292,13 +292,14 @@ type SseFrame<T> = { ok: true; value: T } | { ok: false; raw: string; error: Syn
 /**
  * Shared `data:`-line framing for {@link readSseJson} and
  * {@link readSseJsonOrText}: skips empty events, stops at the OpenAI `[DONE]`
- * sentinel, notifies the diagnostic observer, and treats a container-shaped
- * stream tail as a clean end of iteration.
+ * sentinel (reporting it through `onDone`), notifies the diagnostic observer,
+ * and treats a container-shaped stream tail as a clean end of iteration.
  */
 async function* readSseFrames<T>(
 	stream: ReadableStream<Uint8Array>,
 	signal?: AbortSignal,
 	onEvent?: SseEventObserver,
+	onDone?: () => void,
 ): AsyncGenerator<SseFrame<T>> {
 	// The diagnostic observer is the only reader of `raw`; capture it exactly
 	// when one is attached so the hot path stays allocation-free.
@@ -307,7 +308,10 @@ async function* readSseFrames<T>(
 		notifySseEventObserver(onEvent, sse);
 		const data = sse.data;
 		if (data === "" || data === "[DONE]") {
-			if (data === "[DONE]") return;
+			if (data === "[DONE]") {
+				onDone?.();
+				return;
+			}
 			continue;
 		}
 		try {
@@ -358,8 +362,14 @@ export async function* readSseJsonOrText<T>(
 	stream: ReadableStream<Uint8Array>,
 	signal?: AbortSignal,
 	onEvent?: SseEventObserver,
+	/**
+	 * Called when iteration ends on the OpenAI `[DONE]` sentinel. Lets a
+	 * consumer tell a server-agreed end from a bare EOF without attaching an
+	 * `onEvent` observer (which turns on per-line raw capture).
+	 */
+	onDone?: () => void,
 ): AsyncGenerator<T | string> {
-	for await (const frame of readSseFrames<T>(stream, signal, onEvent)) {
+	for await (const frame of readSseFrames<T>(stream, signal, onEvent, onDone)) {
 		if (!frame.ok) yield frame.raw;
 		else yield frame.value;
 	}
@@ -385,12 +395,13 @@ export interface ServerSentEvent {
 	 * Decoded wire lines for this event (`event:`/`data:`/etc.), for the
 	 * diagnostic pipeline. Populated only when the reader opts in via
 	 * {@link ReadSseEventsOptions.captureRaw} (or attaches an `onSseEvent`
-	 * observer to the JSON readers, which opt in automatically); otherwise
-	 * `[]`. Direct `readSseEvents` callers that need wire text must pass
+	 * observer to the JSON readers, which opt in automatically); otherwise a
+	 * shared, frozen empty array — copy or reassign it, never mutate it in
+	 * place. Direct `readSseEvents` callers that need wire text must pass
 	 * `{ captureRaw: true }` — the field is allocation-free by default so
 	 * the token path pays no per-frame array/slice cost.
 	 */
-	raw: string[];
+	raw: readonly string[];
 	id?: string;
 	retry?: number;
 }
@@ -414,6 +425,13 @@ interface SseEventState {
 // an ASCII line-ending byte, which cannot split a multi-byte UTF-8 sequence.
 const SSE_DECODER = new TextDecoder("utf-8");
 
+/**
+ * `raw` of every event dispatched with capture off. Shared instead of one
+ * fresh array per event; frozen so an in-place mutation throws rather than
+ * leaking lines into every other event (consumers copy or reassign `raw`).
+ */
+const EMPTY_RAW: readonly string[] = Object.freeze<string[]>([]);
+
 function flushSseEvent(state: SseEventState): ServerSentEvent | null {
 	if (state.event === null && state.data === null && state.id === undefined && state.retry === undefined) {
 		if (state.raw !== null) state.raw = [];
@@ -422,7 +440,7 @@ function flushSseEvent(state: SseEventState): ServerSentEvent | null {
 	const event: ServerSentEvent = {
 		event: state.event,
 		data: state.data ?? "",
-		raw: state.raw ?? [],
+		raw: state.raw ?? EMPTY_RAW,
 	};
 	if (state.id !== undefined) event.id = state.id;
 	if (state.retry !== undefined) event.retry = state.retry;

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

@@ -1,41 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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;

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

@@ -1,43 +0,0 @@
-import type { Direction, AsciiEdge, AsciiGraph } from './types.js';
-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

@@ -1,7 +0,0 @@
-import type { AsciiConfig, AsciiTheme, ColorMode } from './types.js';
-/**
- * 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

@@ -1,56 +0,0 @@
-import type { GridCoord, DrawingCoord, Direction, AsciiGraph, AsciiNode, AsciiSubgraph } from './types.js';
-/**
- * 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

@@ -1,65 +0,0 @@
-import { detectColorMode, DEFAULT_ASCII_THEME } from './ansi.js';
-import type { AsciiTheme, ColorMode } from './types.js';
-import type { Direction } from '../types.js';
-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;