@dheerajsom/pinhub 0.1.2 → 0.2.0

package/dist/cli.js

@@ -1,6 +1,22 @@
 #!/usr/bin/env node
 import { runCli } from "./run.js";
-const result = await runCli(process.argv.slice(2));
+import { playSignalPulse, shouldAnimateSignalPulse, signalPulseLabel, } from "./status.js";
+const argv = process.argv.slice(2);
+const resultPromise = runCli(argv);
+const pulsePromise = shouldAnimateSignalPulse(argv, {
+    stdoutIsTTY: Boolean(process.stdout.isTTY),
+    stderrIsTTY: Boolean(process.stderr.isTTY),
+    stderrColumns: process.stderr.columns,
+    env: process.env,
+})
+    ? playSignalPulse(process.stderr, {
+        ascii: argv.includes("--ascii"),
+        label: signalPulseLabel(argv),
+    })
+    : Promise.resolve();
+// Await both concurrently so an unexpected command failure is observed
+// immediately instead of becoming an unhandled rejection during the pulse.
+const [result] = await Promise.all([resultPromise, pulsePromise]);
 if (result.stdout)
     process.stdout.write(result.stdout);
 if (result.stderr)

package/dist/model.d.ts

@@ -9,10 +9,13 @@ export type Warning = {
     severity: WarningSeverity;
     text: string;
 };
+export type SourceType = "Docs" | "Datasheet" | "Manual" | "Schematic" | "Pinout";
 export type Source = {
     title: string;
     url: string;
     official: boolean;
+    /** What the source documents, used to prefer an exact pin map for wiring. */
+    type?: SourceType;
 };
 export type Pin = {
     /** Physical pin number as printed or conventionally counted on the board. */

package/dist/render/board.d.ts

@@ -1,12 +1,14 @@
 import type { ChalkInstance } from "chalk";
 import type { Board } from "../model.js";
-import type { CharSet } from "./chars.js";
+import { type CharSet } from "./chars.js";
+export { wrapText } from "./text.js";
 export type RenderOptions = {
     chalk: ChalkInstance;
     chars: CharSet;
     width: number;
     compact: boolean;
+    /** Show every alternate pin function, in addition to always-visible notes. */
+    details?: boolean;
 };
-export declare function wrapText(text: string, width: number, indent: string): string[];
 export declare function renderWarnings(board: Board, opts: RenderOptions): string[];
 export declare function renderBoard(board: Board, opts: RenderOptions): string;

package/dist/render/board.js

@@ -1,140 +1,187 @@
+import { asciiChars } from "./chars.js";
+import { normalizeWidth, padEndVisible, padStartVisible, toAscii, visibleWidth, wrapText, } from "./text.js";
 import { pinStyle, warningStyle } from "./theme.js";
+export { wrapText } from "./text.js";
 const INDENT = "  ";
-/** Label plus its primary alternate function; reserved pins get a `*` marker. */
-function displayLabel(pin) {
+function renderWidth(opts) {
+    return normalizeWidth(opts.width);
+}
+function finish(text, opts) {
+    return opts.chars === asciiChars ? toAscii(text) : text;
+}
+/** Label plus its primary alternate function and safety-note markers. */
+function displayLabel(pin, ch) {
     const fn = pin.functions?.[0];
     const base = fn && fn !== pin.label ? `${pin.label} / ${fn}` : pin.label;
-    return pin.category === "reserved" ? `${base} *` : base;
+    const reserved = pin.category === "reserved" ? " *" : "";
+    const noted = pin.notes?.length ? ` ${ch.note ?? "^"}` : "";
+    return `${base}${reserved}${noted}`;
 }
 function pinDetails(pin) {
     return pin.voltage ? `${pin.category}, ${pin.voltage}` : pin.category;
 }
-export function wrapText(text, width, indent) {
-    const usable = Math.max(20, width - indent.length);
-    const words = text.split(/\s+/);
-    const lines = [];
-    let line = "";
-    for (const word of words) {
-        if (line && line.length + 1 + word.length > usable) {
-            lines.push(indent + line);
-            line = word;
-        }
-        else {
-            line = line ? `${line} ${word}` : word;
-        }
-    }
-    if (line)
-        lines.push(indent + line);
-    return lines;
-}
 function byPosition(header, column, row) {
-    return header.pins.find((p) => p.position.column === column && p.position.row === row);
+    return header.pins.find((pin) => pin.position.column === column && pin.position.row === row);
 }
 /** Bordered two-column diagram: label | pin | pin | label. */
 function renderDualRowTable(header, opts) {
     const { chalk: c, chars: ch } = opts;
     const rows = [];
-    for (let r = 1; r <= header.layout.rows; r++) {
-        rows.push([byPosition(header, 1, r), byPosition(header, 2, r)]);
+    for (let row = 1; row <= header.layout.rows; row += 1) {
+        rows.push([byPosition(header, 1, row), byPosition(header, 2, row)]);
     }
-    const leftWidth = Math.max(...rows.map(([l]) => (l ? displayLabel(l).length : 0)), 4);
-    const rightWidth = Math.max(...rows.map(([, r]) => (r ? displayLabel(r).length : 0)), 4);
-    const numWidth = Math.max(...header.pins.map((p) => String(p.physical).length), 2);
-    const totalWidth = INDENT.length + leftWidth + rightWidth + 2 * numWidth + 13;
-    if (totalWidth > opts.width)
+    const leftWidth = Math.max(...rows.map(([left]) => (left ? visibleWidth(displayLabel(left, ch)) : 0)), 4);
+    const rightWidth = Math.max(...rows.map(([, right]) => (right ? visibleWidth(displayLabel(right, ch)) : 0)), 4);
+    const numWidth = Math.max(...header.pins.map((pin) => String(pin.physical).length), 2);
+    const horizontal = ch.horizontal;
+    const segment = (width) => horizontal.repeat(width + 2);
+    const top = `${INDENT}${ch.topLeft}${segment(leftWidth)}${ch.topJoin}${segment(numWidth)}${ch.topJoin}${segment(numWidth)}${ch.topJoin}${segment(rightWidth)}${ch.topRight}`;
+    if (visibleWidth(top) > renderWidth(opts))
         return undefined;
-    const h = ch.horizontal;
-    const seg = (n) => h.repeat(n + 2);
-    const lines = [];
-    lines.push(`${INDENT}${ch.topLeft}${seg(leftWidth)}${ch.topJoin}${seg(numWidth)}${ch.topJoin}${seg(numWidth)}${ch.topJoin}${seg(rightWidth)}${ch.topRight}`);
+    const lines = [top];
     for (const [left, right] of rows) {
-        const leftLabel = left ? pinStyle(c, left)(displayLabel(left).padEnd(leftWidth)) : " ".repeat(leftWidth);
-        const rightLabel = right ? pinStyle(c, right)(displayLabel(right).padEnd(rightWidth)) : " ".repeat(rightWidth);
+        const leftLabel = left
+            ? pinStyle(c, left)(padEndVisible(displayLabel(left, ch), leftWidth))
+            : " ".repeat(leftWidth);
+        const rightLabel = right
+            ? pinStyle(c, right)(padEndVisible(displayLabel(right, ch), rightWidth))
+            : " ".repeat(rightWidth);
         const leftNum = left ? String(left.physical).padStart(numWidth) : " ".repeat(numWidth);
         const rightNum = right ? String(right.physical).padStart(numWidth) : " ".repeat(numWidth);
         lines.push(`${INDENT}${ch.vertical} ${leftLabel} ${ch.vertical} ${leftNum} ${ch.vertical} ${rightNum} ${ch.vertical} ${rightLabel} ${ch.vertical}`);
     }
-    lines.push(`${INDENT}${ch.bottomLeft}${seg(leftWidth)}${ch.bottomJoin}${seg(numWidth)}${ch.bottomJoin}${seg(numWidth)}${ch.bottomJoin}${seg(rightWidth)}${ch.bottomRight}`);
+    lines.push(`${INDENT}${ch.bottomLeft}${segment(leftWidth)}${ch.bottomJoin}${segment(numWidth)}${ch.bottomJoin}${segment(numWidth)}${ch.bottomJoin}${segment(rightWidth)}${ch.bottomRight}`);
     return lines;
 }
 /** Borderless two-column pairs for --compact / narrower terminals. */
 function renderDualRowCompact(header, opts) {
     const { chalk: c, chars: ch } = opts;
     const rows = [];
-    for (let r = 1; r <= header.layout.rows; r++) {
-        rows.push([byPosition(header, 1, r), byPosition(header, 2, r)]);
+    for (let row = 1; row <= header.layout.rows; row += 1) {
+        rows.push([byPosition(header, 1, row), byPosition(header, 2, row)]);
     }
-    const leftWidth = Math.max(...rows.map(([l]) => (l ? displayLabel(l).length : 0)), 4);
-    const rightWidth = Math.max(...rows.map(([, r]) => (r ? displayLabel(r).length : 0)), 4);
-    const numWidth = Math.max(...header.pins.map((p) => String(p.physical).length), 2);
-    const totalWidth = INDENT.length + leftWidth + 2 + numWidth + 3 + numWidth + 2 + rightWidth;
-    if (totalWidth > opts.width)
+    const leftWidth = Math.max(...rows.map(([left]) => (left ? visibleWidth(displayLabel(left, ch)) : 0)), 4);
+    const rightWidth = Math.max(...rows.map(([, right]) => (right ? visibleWidth(displayLabel(right, ch)) : 0)), 4);
+    const numWidth = Math.max(...header.pins.map((pin) => String(pin.physical).length), 2);
+    const widest = `${INDENT}${" ".repeat(leftWidth)}  ${" ".repeat(numWidth)} ${ch.pairSeparator} ${" ".repeat(numWidth)}  ${" ".repeat(rightWidth)}`;
+    if (visibleWidth(widest) > renderWidth(opts))
         return undefined;
     return rows.map(([left, right]) => {
-        const leftLabel = left ? pinStyle(c, left)(displayLabel(left).padStart(leftWidth)) : " ".repeat(leftWidth);
-        const rightLabel = right ? pinStyle(c, right)(displayLabel(right)) : "";
+        const leftLabel = left
+            ? pinStyle(c, left)(padStartVisible(displayLabel(left, ch), leftWidth))
+            : " ".repeat(leftWidth);
+        const rightLabel = right ? pinStyle(c, right)(displayLabel(right, ch)) : "";
         const leftNum = left ? String(left.physical).padStart(numWidth) : " ".repeat(numWidth);
         const rightNum = right ? String(right.physical).padEnd(numWidth) : " ".repeat(numWidth);
         return `${INDENT}${leftLabel}  ${leftNum} ${ch.pairSeparator} ${rightNum}  ${rightLabel}`.trimEnd();
     });
 }
-/** One pin per line — always fits; last-resort fallback and 1-column layout. */
+/** One pin per line, wrapping label and details independently when necessary. */
 function renderPinList(header, opts) {
-    const { chalk: c } = opts;
-    const pins = [...header.pins].sort((a, b) => a.physical - b.physical);
-    const numWidth = Math.max(...pins.map((p) => String(p.physical).length), 2);
-    const labelWidth = Math.max(...pins.map((p) => displayLabel(p).length), 4);
-    return pins.map((pin) => {
-        const label = pinStyle(c, pin)(displayLabel(pin).padEnd(labelWidth));
-        return `${INDENT}${String(pin.physical).padStart(numWidth)}  ${label}  ${c.dim(pinDetails(pin))}`;
+    const { chalk: c, chars: ch } = opts;
+    const width = renderWidth(opts);
+    const pins = [...header.pins].sort((left, right) => left.physical - right.physical);
+    const numWidth = Math.max(...pins.map((pin) => String(pin.physical).length), 2);
+    const labelWidth = Math.max(...pins.map((pin) => visibleWidth(displayLabel(pin, ch))), 4);
+    const detailWidth = Math.max(...pins.map((pin) => visibleWidth(pinDetails(pin))), 4);
+    const alignedWidth = visibleWidth(INDENT) + numWidth + 2 + labelWidth + 2 + detailWidth;
+    return pins.flatMap((pin) => {
+        const number = String(pin.physical).padStart(numWidth);
+        const label = displayLabel(pin, ch);
+        const details = pinDetails(pin);
+        if (alignedWidth <= width) {
+            return [
+                `${INDENT}${number}  ${pinStyle(c, pin)(padEndVisible(label, labelWidth))}  ${c.dim(details)}`,
+            ];
+        }
+        const singleLine = `${INDENT}${number}  ${label}  ${details}`;
+        if (visibleWidth(singleLine) <= width) {
+            return [`${INDENT}${number}  ${pinStyle(c, pin)(label)}  ${c.dim(details)}`];
+        }
+        const prefix = `${INDENT}${number}  `;
+        const continuation = " ".repeat(visibleWidth(prefix));
+        const labelLines = wrapText(label, width, prefix, continuation).map((line) => pinStyle(c, pin)(line));
+        const detailLines = wrapText(details, width, continuation, continuation).map((line) => c.dim(line));
+        return [...labelLines, ...detailLines];
     });
 }
 /** Bordered single-column table: # | pin | details. */
 function renderSingleColumnTable(header, opts) {
     const { chalk: c, chars: ch } = opts;
-    const pins = [...header.pins].sort((a, b) => a.physical - b.physical);
-    const numWidth = Math.max(...pins.map((p) => String(p.physical).length), 2);
-    const labelWidth = Math.max(...pins.map((p) => displayLabel(p).length), 4);
-    const detailWidth = Math.max(...pins.map((p) => pinDetails(p).length), 4);
-    const totalWidth = INDENT.length + numWidth + labelWidth + detailWidth + 10;
-    if (totalWidth > opts.width)
+    const pins = [...header.pins].sort((left, right) => left.physical - right.physical);
+    const numWidth = Math.max(...pins.map((pin) => String(pin.physical).length), 2);
+    const labelWidth = Math.max(...pins.map((pin) => visibleWidth(displayLabel(pin, ch))), 4);
+    const detailWidth = Math.max(...pins.map((pin) => visibleWidth(pinDetails(pin))), 4);
+    const horizontal = ch.horizontal;
+    const segment = (width) => horizontal.repeat(width + 2);
+    const top = `${INDENT}${ch.topLeft}${segment(numWidth)}${ch.topJoin}${segment(labelWidth)}${ch.topJoin}${segment(detailWidth)}${ch.topRight}`;
+    if (visibleWidth(top) > renderWidth(opts))
         return undefined;
-    const h = ch.horizontal;
-    const seg = (n) => h.repeat(n + 2);
-    const lines = [];
-    lines.push(`${INDENT}${ch.topLeft}${seg(numWidth)}${ch.topJoin}${seg(labelWidth)}${ch.topJoin}${seg(detailWidth)}${ch.topRight}`);
+    const lines = [top];
     for (const pin of pins) {
-        const label = pinStyle(c, pin)(displayLabel(pin).padEnd(labelWidth));
-        lines.push(`${INDENT}${ch.vertical} ${String(pin.physical).padStart(numWidth)} ${ch.vertical} ${label} ${ch.vertical} ${pinDetails(pin).padEnd(detailWidth)} ${ch.vertical}`);
+        const label = pinStyle(c, pin)(padEndVisible(displayLabel(pin, ch), labelWidth));
+        lines.push(`${INDENT}${ch.vertical} ${String(pin.physical).padStart(numWidth)} ${ch.vertical} ${label} ${ch.vertical} ${padEndVisible(pinDetails(pin), detailWidth)} ${ch.vertical}`);
+    }
+    lines.push(`${INDENT}${ch.bottomLeft}${segment(numWidth)}${ch.bottomJoin}${segment(labelWidth)}${ch.bottomJoin}${segment(detailWidth)}${ch.bottomRight}`);
+    return lines;
+}
+function renderPinAnnotations(header, opts) {
+    const { chalk: c, chars: ch } = opts;
+    const width = renderWidth(opts);
+    const pins = [...header.pins].sort((left, right) => left.physical - right.physical);
+    const annotated = pins.filter((pin) => Boolean(pin.notes?.length) || (Boolean(opts.details) && (pin.functions?.length ?? 0) > 1));
+    const lines = [];
+    if (annotated.length > 0) {
+        lines.push(c.bold("Pin notes"));
+        for (const pin of annotated) {
+            const details = [];
+            if (opts.details && (pin.functions?.length ?? 0) > 1) {
+                details.push(`additional functions: ${pin.functions.slice(1).join(", ")}`);
+            }
+            details.push(...(pin.notes ?? []));
+            const prefix = `${INDENT}${ch.note ?? "^"} Pin ${pin.physical}: `;
+            const continuation = " ".repeat(visibleWidth(prefix));
+            lines.push(...wrapText(details.join("; "), width, prefix, continuation));
+        }
+    }
+    if (!opts.details) {
+        const hiddenAlternates = pins.filter((pin) => (pin.functions?.length ?? 0) > 1).length;
+        if (hiddenAlternates > 0) {
+            if (lines.length > 0)
+                lines.push("");
+            lines.push(...wrapText(`${ch.info} ${hiddenAlternates} pin${hiddenAlternates === 1 ? " has" : "s have"} additional alternate functions; use --details to show them.`, width, INDENT, `${INDENT}  `).map((line) => c.dim(line)));
+        }
     }
-    lines.push(`${INDENT}${ch.bottomLeft}${seg(numWidth)}${ch.bottomJoin}${seg(labelWidth)}${ch.bottomJoin}${seg(detailWidth)}${ch.bottomRight}`);
     return lines;
 }
 function renderHeader(header, opts) {
     const { chalk: c } = opts;
-    const lines = [];
-    lines.push(c.bold(header.name));
+    const width = renderWidth(opts);
+    const lines = wrapText(header.name, width).map((line) => c.bold(line));
     if (header.description) {
-        lines.push(...wrapText(header.description, opts.width, INDENT).map((l) => c.dim(l)));
+        lines.push(...wrapText(header.description, width, INDENT).map((line) => c.dim(line)));
     }
     let table;
     if (header.layout.columns === 2) {
         table = opts.compact
-            ? renderDualRowCompact(header, opts) ?? renderPinList(header, opts)
-            : renderDualRowTable(header, opts) ??
+            ? (renderDualRowCompact(header, opts) ?? renderPinList(header, opts))
+            : (renderDualRowTable(header, opts) ??
                 renderDualRowCompact(header, opts) ??
-                renderPinList(header, opts);
+                renderPinList(header, opts));
     }
     else {
-        table = opts.compact ? renderPinList(header, opts) : renderSingleColumnTable(header, opts) ?? renderPinList(header, opts);
+        table = opts.compact
+            ? renderPinList(header, opts)
+            : (renderSingleColumnTable(header, opts) ?? renderPinList(header, opts));
     }
     lines.push(...table);
+    const annotations = renderPinAnnotations(header, opts);
+    if (annotations.length > 0)
+        lines.push("", ...annotations);
     return lines;
 }
 function renderLegend(board, opts) {
-    const { chalk: c } = opts;
-    if (c.level === 0)
-        return [];
+    const { chalk: c, chars: ch } = opts;
     const order = [
         "power",
         "ground",
@@ -145,39 +192,68 @@ function renderLegend(board, opts) {
         "reserved",
         "nc",
     ];
-    const present = order.filter((cat) => board.headers.some((h) => h.pins.some((p) => p.category === cat)));
-    const swatches = present.map((cat) => {
+    const present = order.filter((category) => board.headers.some((header) => header.pins.some((pin) => pin.category === category)));
+    if (present.length === 0)
+        return [];
+    const swatches = present.map((category) => {
         const sample = board.headers
-            .flatMap((h) => h.pins)
-            .find((p) => p.category === cat);
-        return pinStyle(c, sample)(cat);
+            .flatMap((header) => header.pins)
+            .find((pin) => pin.category === category);
+        return c.level === 0 ? category : pinStyle(c, sample)(category);
     });
-    return [c.dim("Legend: ") + swatches.join(c.dim(" · "))];
+    return wrapText(`Legend: ${swatches.join(` ${ch.itemSeparator ?? "|"} `)}`, renderWidth(opts)).map((line) => c.dim(line));
+}
+function warningMarker(ch, severity) {
+    switch (severity) {
+        case "danger":
+            return ch.danger ?? ch.warn;
+        case "warning":
+            return ch.warn;
+        case "info":
+            return ch.info;
+    }
 }
 export function renderWarnings(board, opts) {
     const { chalk: c, chars: ch } = opts;
     return board.warnings.flatMap((warning) => {
-        const marker = warning.severity === "info" ? ch.info : ch.warn;
+        const marker = warningMarker(ch, warning.severity);
         const style = warningStyle(c, warning.severity);
-        return wrapText(`${marker} ${warning.text}`, opts.width, "").map((line, i) => style(i === 0 ? line : `  ${line}`));
+        return wrapText(`${marker} ${warning.text}`, renderWidth(opts), "", INDENT).map((line) => style(line));
     });
 }
+function primarySourceFor(board) {
+    const typeScore = {
+        Pinout: 2000,
+        Schematic: 800,
+        Datasheet: 70,
+        Manual: 60,
+        Docs: 50,
+    };
+    return board.sources.reduce((best, source) => {
+        if (!best)
+            return source;
+        const score = (source.official ? 1000 : 0) + (source.type ? typeScore[source.type] : 0);
+        const bestScore = (best.official ? 1000 : 0) + (best.type ? typeScore[best.type] : 0);
+        return score > bestScore ? source : best;
+    }, undefined);
+}
 export function renderBoard(board, opts) {
     const { chalk: c, chars: ch } = opts;
+    const width = renderWidth(opts);
     const lines = [];
-    lines.push(`${c.bold(board.name)} ${c.dim(`— ${board.manufacturer}`)}`);
-    const primarySource = board.sources.find((s) => s.official) ?? board.sources[0];
+    lines.push(...wrapText(`${board.name} ${ch.dash ?? "-"} ${board.manufacturer}`, width).map((line) => c.bold(line)));
+    const primarySource = primarySourceFor(board);
     if (primarySource) {
         const tag = primarySource.official ? "official" : "third-party";
-        lines.push(c.dim(`Source: ${primarySource.title} (${tag}) — see ph ${board.id} --source`));
+        lines.push(...wrapText(`Source: ${primarySource.title} (${tag}) ${ch.dash ?? "-"} see ph ${board.id} --source`, width, "", INDENT).map((line) => c.dim(line)));
     }
     if (board.revisionNote) {
-        lines.push(...wrapText(`${ch.info} ${board.revisionNote}`, opts.width, "").map((line, i) => c.dim(i === 0 ? line : `  ${line}`)));
+        lines.push(...wrapText(`${ch.info} ${board.revisionNote}`, width, "", INDENT).map((line) => c.dim(line)));
     }
     lines.push(...renderWarnings(board, opts));
     lines.push("");
     if (board.headers.length === 0) {
-        lines.push(c.dim(`No pinout data for this board yet — see ph ${board.id} --source for documentation.`));
+        lines.push(...wrapText(`No pinout data for this board yet ${ch.dash ?? "-"} see ph ${board.id} --source for documentation.`, width).map((line) => c.dim(line)));
     }
     board.headers.forEach((header, index) => {
         if (index > 0)
@@ -185,13 +261,15 @@ export function renderBoard(board, opts) {
         lines.push(...renderHeader(header, opts));
     });
     const legend = renderLegend(board, opts);
-    if (legend.length > 0) {
-        lines.push("");
-        lines.push(...legend);
-    }
-    const hasReserved = board.headers.some((h) => h.pins.some((p) => p.category === "reserved"));
+    if (legend.length > 0)
+        lines.push("", ...legend);
+    const hasReserved = board.headers.some((header) => header.pins.some((pin) => pin.category === "reserved"));
     if (hasReserved) {
-        lines.push(c.dim("* reserved / control pin — see warnings above"));
+        lines.push(...wrapText(`* reserved / control pin ${ch.dash ?? "-"} see warnings above`, width).map((line) => c.dim(line)));
+    }
+    const hasNotes = board.headers.some((header) => header.pins.some((pin) => pin.notes?.length));
+    if (hasNotes) {
+        lines.push(...wrapText(`${ch.note ?? "^"} pin-specific note`, width).map((line) => c.dim(line)));
     }
-    return lines.join("\n");
+    return finish(lines.join("\n"), opts);
 }

package/dist/render/chars.d.ts

@@ -7,10 +7,14 @@ export type CharSet = {
     vertical: string;
     topJoin: string;
     bottomJoin: string;
+    danger?: string;
     warn: string;
     info: string;
+    note?: string;
     bullet: string;
     pairSeparator: string;
+    dash?: string;
+    itemSeparator?: string;
 };
 export declare const unicodeChars: CharSet;
 export declare const asciiChars: CharSet;

package/dist/render/chars.js

@@ -7,10 +7,14 @@ export const unicodeChars = {
     vertical: "│",
     topJoin: "┬",
     bottomJoin: "┴",
+    danger: "✖",
     warn: "⚠",
     info: "ℹ",
+    note: "†",
     bullet: "•",
     pairSeparator: "│",
+    dash: "—",
+    itemSeparator: "·",
 };
 export const asciiChars = {
     topLeft: "+",
@@ -21,8 +25,12 @@ export const asciiChars = {
     vertical: "|",
     topJoin: "+",
     bottomJoin: "+",
+    danger: "X",
     warn: "!",
     info: "i",
+    note: "^",
     bullet: "*",
     pairSeparator: "|",
+    dash: "-",
+    itemSeparator: ".",
 };

package/dist/render/meta.d.ts

@@ -1,6 +1,6 @@
-import type { ChalkInstance } from "chalk";
 import type { Board } from "../model.js";
-import type { CharSet } from "./chars.js";
-export declare function renderBoardTable(boardList: Board[], c: ChalkInstance): string;
-export declare function renderSources(board: Board, c: ChalkInstance): string;
-export declare function renderInfo(board: Board, c: ChalkInstance, ch: CharSet, width: number): string;
+import type { RenderOptions } from "./board.js";
+/** Width-responsive catalog/search table; cells wrap instead of being truncated. */
+export declare function renderBoardTable(boardList: Board[], opts: RenderOptions): string;
+export declare function renderSources(board: Board, opts: RenderOptions): string;
+export declare function renderInfo(board: Board, opts: RenderOptions): string;