@oh-my-pi/pi-utils 18.2.6 → 18.2.8

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [18.2.7] - 2026-09-21
+
+### Changed
+
+- Mermaid diagrams are now rendered with the native renderer, with output remaining unchanged.
+- PI_TIMING span lines now include their start offset to make unspanned gaps easier to identify.
+
+### Fixed
+
+- Fixed a startup crash when PI_TIMING profiled modules loaded via require() or TypeScript declaration assets.
+
 ## [18.2.5] - 2026-09-17
 
 ### Added
@@ -587,7 +598,7 @@
 
 ### Changed
 
-- Mermaid diagrams are now rendered to ASCII by a first-party vendored renderer (`src/vendor/mermaid-ascii`, derived from the MIT-licensed `beautiful-mermaid`, ASCII pipeline only) with terminal display width measured via `Bun.stringWidth` (grapheme-aware, correct for wide/East-Asian glyphs and emoji). Inline label formatting (HTML formatting tags and markdown emphasis) is now reduced to plain text instead of printed raw.
+- Mermaid diagrams are now rendered to ASCII by a first-party renderer (initially derived from the MIT-licensed `beautiful-mermaid`, ASCII pipeline only) with terminal display width measured via `Bun.stringWidth` (grapheme-aware, correct for wide/East-Asian glyphs and emoji). Inline label formatting (HTML formatting tags and markdown emphasis) is now reduced to plain text instead of printed raw.
 
 ### Removed
 

package/THIRD-PARTY-NOTICES.txt

@@ -335,43 +335,6 @@ This license allows the work and adaptations of it to be shared and used
 commercially, as long as it is attributed to Poppy Works. The font is bundled
 here (crates/pi-natives/src/fonts/Silver.ttf) as a CJK/Unicode bitmap fallback.
 
--------------------------------------------------------------------------------
-packages/utils/src/vendor/mermaid-ascii/NOTICE
-
-This directory contains an in-house Mermaid-diagram-to-ASCII renderer adapted
-from beautiful-mermaid (https://github.com/lukilabs/beautiful-mermaid), used
-under the MIT License.
-
-  Copyright (c) 2026 Craft Docs
-
-Only the ASCII rendering pipeline is ported (flowchart/state, sequence, class,
-ER, and xychart diagrams); the SVG renderer and its `elkjs` graph-layout
-dependency, the browser entry point, and the SVG theme/style modules were
-dropped. Terminal display width is reimplemented on `Bun.stringWidth`, and
-inline label formatting (HTML tags, markdown emphasis) is reduced to plain text
-for ASCII output. Layout and edge-routing logic is preserved faithfully so
-ASCII output matches the upstream package.
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
 -------------------------------------------------------------------------------
 packages/coding-agent/src/markit/NOTICE
 

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

@@ -1,7 +1,15 @@
-import { type AsciiRenderOptions } from "./vendor/mermaid-ascii/index.js";
-export type { AsciiRenderOptions as MermaidAsciiRenderOptions };
-export declare function renderMermaidAscii(source: string, options?: AsciiRenderOptions): string;
-export declare function renderMermaidAsciiSafe(source: string, options?: AsciiRenderOptions): string | null;
+import { type MermaidRenderOptions, renderMermaidAscii } from "@oh-my-pi/pi-natives";
+/**
+ * Native Mermaid → ASCII/Unicode renderer (flowchart, state, sequence, class,
+ * ER, xychart). Synchronous because callers render inside the compositor;
+ * throws on empty input, an unknown flowchart header, or an invalid
+ * `direction`/`colorMode` value.
+ */
+export { renderMermaidAscii };
+/** Options for {@link renderMermaidAscii}; every field optional. */
+export type MermaidAsciiRenderOptions = MermaidRenderOptions;
+/** {@link renderMermaidAscii}, returning `null` instead of throwing. */
+export declare function renderMermaidAsciiSafe(source: string, options?: MermaidAsciiRenderOptions): string | null;
 /**
  * Extract mermaid code blocks from markdown text.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.2.6",
+	"version": "18.2.8",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"cli",
@@ -54,7 +54,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.2.6"
+		"@oh-my-pi/pi-natives": "18.2.8"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/logger.ts

@@ -644,7 +644,9 @@ function printSpan(span: Span, depth: number, lines: string[]): void {
 	const tag = parallel ? " [parallel]" : "";
 	const self = selfTimeOf(span);
 	const selfStr = span.children.length > 0 && self > LOGGED_TIMING_THRESHOLD_MS ? ` (self ${fmtMs(self)})` : "";
-	lines.push(`${indent}${span.op}: ${fmtMs(dur)}${selfStr}${tag}`);
+	// Start offset from process origin: gaps between consecutive siblings are
+	// the parent's own (unspanned) work, which duration alone cannot locate.
+	lines.push(`${indent}${span.op}: ${fmtMs(dur)}${selfStr}${tag} @${span.start.toFixed(0)}ms`);
 
 	// Split children into work spans and module-load spans for summarization.
 	const work: Span[] = [];

package/src/mermaid-ascii.ts

@@ -1,14 +1,20 @@
-import { type AsciiRenderOptions, renderMermaidASCII } from "./vendor/mermaid-ascii";
+import { type MermaidRenderOptions, renderMermaidAscii } from "@oh-my-pi/pi-natives";
 
-export type { AsciiRenderOptions as MermaidAsciiRenderOptions };
+/**
+ * Native Mermaid → ASCII/Unicode renderer (flowchart, state, sequence, class,
+ * ER, xychart). Synchronous because callers render inside the compositor;
+ * throws on empty input, an unknown flowchart header, or an invalid
+ * `direction`/`colorMode` value.
+ */
+export { renderMermaidAscii };
 
-export function renderMermaidAscii(source: string, options?: AsciiRenderOptions): string {
-	return renderMermaidASCII(source, options);
-}
+/** Options for {@link renderMermaidAscii}; every field optional. */
+export type MermaidAsciiRenderOptions = MermaidRenderOptions;
 
-export function renderMermaidAsciiSafe(source: string, options?: AsciiRenderOptions): string | null {
+/** {@link renderMermaidAscii}, returning `null` instead of throwing. */
+export function renderMermaidAsciiSafe(source: string, options?: MermaidAsciiRenderOptions): string | null {
 	try {
-		return renderMermaidASCII(source, options);
+		return renderMermaidAscii(source, options);
 	} catch {
 		return null;
 	}

package/src/module-timer.ts

@@ -40,6 +40,7 @@
  * - **Dev runs only.** In the compiled `omp` binary every module is pre-bundled
  *   into bunfs, so `onLoad` never fires; profile with a `bun --preload` dev run.
  */
+import { readFileSync } from "node:fs";
 import { plugin } from "bun";
 import { moduleLoadBuffer } from "./timing-buffer";
 
@@ -48,8 +49,8 @@ import { moduleLoadBuffer } from "./timing-buffer";
 // `{ contents, loader: "js" }`, Bun forces ESM and CJS modules fail to load
 // (e.g. `Missing 'default' export`). Our own source tree (where the interesting
 // timing lives) is uniformly TypeScript, so a TS-only filter is both safe and
-// sufficient.
-const MODULE_LOADER_FILTER = /\.[mc]?tsx?$/;
+// sufficient. Declaration files are imported as text assets, never evaluated.
+const MODULE_LOADER_FILTER = /^(?!.*\.d\.[mc]?ts$).*\.[mc]?tsx?$/;
 const MODULE_COMPLETE_KEY: symbol = Symbol.for("omp.moduleLoadComplete");
 const MODULE_BODY_START_KEY: symbol = Symbol.for("omp.moduleBodyStart");
 const STATIC_IMPORT_PATTERN =
@@ -133,10 +134,12 @@ if (process.env.PI_TIMING) {
 	plugin({
 		name: "pi-module-load-timer",
 		setup(build) {
-			build.onLoad({ filter: MODULE_LOADER_FILTER }, async args => {
+			// Synchronous on purpose: a module served by an async onLoad cannot be
+			// `require()`d (cli.ts requires postmortem through Bun's CJS bridge).
+			build.onLoad({ filter: MODULE_LOADER_FILTER }, args => {
 				starts.set(args.path, performance.now());
 				childSetFor(importsByPath, args.path);
-				const contents = await Bun.file(args.path).text();
+				const contents = readFileSync(args.path, "utf8");
 				addImportEdges(importsByPath, args.path, contents);
 				return {
 					contents: instrumentContents(args.path, contents),

package/src/ptree.ts

@@ -462,7 +462,7 @@ export class ChildProcess<In extends InMask = InMask> {
 		return out + dec.decode();
 	}
 
-	async #readBytes(): Promise<Uint8Array> {
+	async #readBytes(): Promise<Uint8Array<ArrayBuffer>> {
 		const reader = this.proc.stdout.getReader();
 		this.#openPipeReaders++;
 		const chunks: Uint8Array[] = [];
@@ -497,7 +497,7 @@ export class ChildProcess<In extends InMask = InMask> {
 		return bytes;
 	}
 
-	async #readOutputBytes(waitForCleanExit = false): Promise<Uint8Array> {
+	async #readOutputBytes(waitForCleanExit = false): Promise<Uint8Array<ArrayBuffer>> {
 		const p = this.#readBytes();
 		if (this.#nothrow) return p;
 		const bytes = waitForCleanExit ? (await Promise.all([p, this.exitedCleanly]))[0] : await p;
@@ -514,7 +514,7 @@ export class ChildProcess<In extends InMask = InMask> {
 	}
 
 	async arrayBuffer(): Promise<ArrayBuffer> {
-		return (await this.#readOutputBytes()).buffer as ArrayBuffer;
+		return (await this.#readOutputBytes()).buffer;
 	}
 
 	async bytes(): Promise<Uint8Array> {

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;