diff --git a/package-lock.json b/package-lock.json
index cecff000d8..d21ebc152d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11,7 +11,7 @@
"packages/*"
],
"dependencies": {
- "ink": "npm:@jrichman/ink@6.4.8",
+ "ink": "npm:@jrichman/ink@6.4.10",
"latest-version": "^9.0.0",
"proper-lockfile": "^4.1.2",
"simple-git": "^3.28.0"
@@ -10019,9 +10019,9 @@
},
"node_modules/ink": {
"name": "@jrichman/ink",
- "version": "6.4.8",
- "resolved": "https://registry.npmjs.org/@jrichman/ink/-/ink-6.4.8.tgz",
- "integrity": "sha512-v0thcXIKl9hqF/1w4HqA6MKxIcMoWSP3YtEZIAA+eeJngXpN5lGnMkb6rllB7FnOdwyEyYaFTcu1ZVr4/JZpWQ==",
+ "version": "6.4.10",
+ "resolved": "https://registry.npmjs.org/@jrichman/ink/-/ink-6.4.10.tgz",
+ "integrity": "sha512-kjJqZFkGVm0QyJmga/L02rsFJroF1aP2bhXEGkpuuT7clB6/W+gxAbLNw7ZaJrG6T30DgqOT92Pu6C9mK1FWyg==",
"license": "MIT",
"peer": true,
"dependencies": {
@@ -17321,7 +17321,7 @@
"fzf": "^0.5.2",
"glob": "^12.0.0",
"highlight.js": "^11.11.1",
- "ink": "npm:@jrichman/ink@6.4.8",
+ "ink": "npm:@jrichman/ink@6.4.10",
"ink-gradient": "^3.0.0",
"ink-spinner": "^5.0.0",
"latest-version": "^9.0.0",
diff --git a/package.json b/package.json
index 77c34b14f5..c850497013 100644
--- a/package.json
+++ b/package.json
@@ -64,7 +64,7 @@
"pre-commit": "node scripts/pre-commit.js"
},
"overrides": {
- "ink": "npm:@jrichman/ink@6.4.8",
+ "ink": "npm:@jrichman/ink@6.4.10",
"wrap-ansi": "9.0.2",
"cliui": {
"wrap-ansi": "7.0.0"
@@ -126,7 +126,7 @@
"yargs": "^17.7.2"
},
"dependencies": {
- "ink": "npm:@jrichman/ink@6.4.8",
+ "ink": "npm:@jrichman/ink@6.4.10",
"latest-version": "^9.0.0",
"proper-lockfile": "^4.1.2",
"simple-git": "^3.28.0"
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 680ae04155..ab9a5c7b86 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -47,7 +47,7 @@
"fzf": "^0.5.2",
"glob": "^12.0.0",
"highlight.js": "^11.11.1",
- "ink": "npm:@jrichman/ink@6.4.8",
+ "ink": "npm:@jrichman/ink@6.4.10",
"ink-gradient": "^3.0.0",
"ink-spinner": "^5.0.0",
"latest-version": "^9.0.0",
diff --git a/packages/cli/src/ui/utils/TableRenderer.test.tsx b/packages/cli/src/ui/utils/TableRenderer.test.tsx
index dd807154d6..1059f841fe 100644
--- a/packages/cli/src/ui/utils/TableRenderer.test.tsx
+++ b/packages/cli/src/ui/utils/TableRenderer.test.tsx
@@ -61,4 +61,257 @@ describe('TableRenderer', () => {
expect(output).toContain('Data 3.4');
expect(output).toMatchSnapshot();
});
+
+ it('wraps long cell content correctly', () => {
+ const headers = ['Col 1', 'Col 2', 'Col 3'];
+ const rows = [
+ [
+ 'Short',
+ 'This is a very long cell content that should wrap to multiple lines',
+ 'Short',
+ ],
+ ];
+ const terminalWidth = 50;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ );
+
+ const output = lastFrame();
+ expect(output).toContain('This is a very');
+ expect(output).toContain('long cell');
+ expect(output).toMatchSnapshot();
+ });
+
+ it('wraps all long columns correctly', () => {
+ const headers = ['Col 1', 'Col 2', 'Col 3'];
+ const rows = [
+ [
+ 'This is a very long text that needs wrapping in column 1',
+ 'This is also a very long text that needs wrapping in column 2',
+ 'And this is the third long text that needs wrapping in column 3',
+ ],
+ ];
+ const terminalWidth = 60;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ );
+
+ const output = lastFrame();
+ expect(output).toContain('wrapping in');
+ expect(output).toMatchSnapshot();
+ });
+
+ it('wraps mixed long and short columns correctly', () => {
+ const headers = ['Short', 'Long', 'Medium'];
+ const rows = [
+ [
+ 'Tiny',
+ 'This is a very long text that definitely needs to wrap to the next line',
+ 'Not so long',
+ ],
+ ];
+ const terminalWidth = 50;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ );
+
+ const output = lastFrame();
+ expect(output).toContain('Tiny');
+ expect(output).toContain('definitely needs');
+ expect(output).toMatchSnapshot();
+ });
+
+ // The snapshot looks weird but checked on VS Code terminal and it looks fine
+ it('wraps columns with punctuation correctly', () => {
+ const headers = ['Punctuation 1', 'Punctuation 2', 'Punctuation 3'];
+ const rows = [
+ [
+ 'Start. Stop. Comma, separated. Exclamation! Question? hyphen-ated',
+ 'Semi; colon: Pipe| Slash/ Backslash\\',
+ 'At@ Hash# Dollar$ Percent% Caret^ Ampersand& Asterisk*',
+ ],
+ ];
+ const terminalWidth = 60;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ );
+
+ const output = lastFrame();
+ expect(output).toContain('Start. Stop.');
+ expect(output).toMatchSnapshot();
+ });
+
+ it('strips bold markers from headers and renders them correctly', () => {
+ const headers = ['**Bold Header**', 'Normal Header', '**Another Bold**'];
+ const rows = [['Data 1', 'Data 2', 'Data 3']];
+ const terminalWidth = 50;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ );
+
+ const output = lastFrame();
+ // The output should NOT contain the literal '**'
+ expect(output).not.toContain('**Bold Header**');
+ expect(output).toContain('Bold Header');
+ expect(output).toMatchSnapshot();
+ });
+
+ it('handles wrapped bold headers without showing markers', () => {
+ const headers = [
+ '**Very Long Bold Header That Will Wrap**',
+ 'Short',
+ '**Another Long Header**',
+ ];
+ const rows = [['Data 1', 'Data 2', 'Data 3']];
+ const terminalWidth = 40;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ );
+
+ const output = lastFrame();
+ // Markers should be gone
+ expect(output).not.toContain('**');
+ expect(output).toContain('Very Long');
+ expect(output).toMatchSnapshot();
+ });
+
+ it('renders a complex table with mixed content lengths correctly', () => {
+ const headers = [
+ 'Comprehensive Architectural Specification for the Distributed Infrastructure Layer',
+ 'Implementation Details for the High-Throughput Asynchronous Message Processing Pipeline with Extended Scalability Features and Redundancy Protocols',
+ 'Longitudinal Performance Analysis Across Multi-Regional Cloud Deployment Clusters',
+ 'Strategic Security Framework for Mitigating Sophisticated Cross-Site Scripting Vulnerabilities',
+ 'Key',
+ 'Status',
+ 'Version',
+ 'Owner',
+ ];
+ const rows = [
+ [
+ 'The primary architecture utilizes a decoupled microservices approach, leveraging container orchestration for scalability and fault tolerance in high-load scenarios.\n\nThis layer provides the fundamental building blocks for service discovery, load balancing, and inter-service communication via highly efficient protocol buffers.\n\nAdvanced telemetry and logging integrations allow for real-time monitoring of system health and rapid identification of bottlenecks within the service mesh.',
+ 'Each message is processed through a series of specialized workers that handle data transformation, validation, and persistent storage using a persistent queue.\n\nThe pipeline features built-in retry mechanisms with exponential backoff to ensure message delivery integrity even during transient network or service failures.\n\nHorizontal autoscaling is triggered automatically based on the depth of the processing queue, ensuring consistent performance during unexpected traffic spikes.',
+ 'Historical data indicates a significant reduction in tail latency when utilizing edge computing nodes closer to the geographic location of the end-user base.\n\nMonitoring tools have captured a steady increase in throughput efficiency since the introduction of the vectorized query engine in the primary data warehouse.\n\nResource utilization metrics demonstrate that the transition to serverless compute for intermittent tasks has resulted in a thirty percent cost optimization.',
+ 'A multi-layered defense strategy incorporates content security policies, input sanitization libraries, and regular automated penetration testing routines.\n\nDevelopers are required to undergo mandatory security training focusing on the OWASP Top Ten to ensure that security is integrated into the initial design phase.\n\nThe implementation of a robust Identity and Access Management system ensures that the principle of least privilege is strictly enforced across all environments.',
+ 'INF',
+ 'Active',
+ 'v2.4',
+ 'J. Doe',
+ ],
+ ];
+
+ const terminalWidth = 160;
+
+ const { lastFrame } = renderWithProviders(
+ ,
+ { width: terminalWidth },
+ );
+
+ const output = lastFrame();
+
+ expect(output).toContain('Comprehensive Architectural');
+ expect(output).toContain('protocol buffers');
+ expect(output).toContain('exponential backoff');
+ expect(output).toContain('vectorized query engine');
+ expect(output).toContain('OWASP Top Ten');
+ expect(output).toContain('INF');
+ expect(output).toContain('Active');
+ expect(output).toContain('v2.4');
+ // "J. Doe" might wrap due to column width constraints
+ expect(output).toContain('J.');
+ expect(output).toContain('Doe');
+
+ expect(output).toMatchSnapshot();
+ });
+
+ it.each([
+ {
+ name: 'handles non-ASCII characters (emojis and Asian scripts) correctly',
+ headers: ['Emoji π', 'Asian ζ±ε', 'Mixed π Text'],
+ rows: [
+ ['Start π End', 'δ½ ε₯½δΈη', 'Rocket π Man'],
+ ['Thumbs π Up', 'γγγ«γ‘γ―', 'Fire π₯'],
+ ],
+ terminalWidth: 60,
+ expected: ['Emoji π', 'Asian ζ±ε', 'δ½ ε₯½δΈη'],
+ },
+ {
+ name: 'renders a table with only emojis and text correctly',
+ headers: ['Happy π', 'Rocket π', 'Heart β€οΈ'],
+ rows: [
+ ['Smile π', 'Fire π₯', 'Love π'],
+ ['Cool π', 'Star β', 'Blue π'],
+ ],
+ terminalWidth: 60,
+ expected: ['Happy π', 'Smile π', 'Fire π₯'],
+ },
+ {
+ name: 'renders a table with only Asian characters and text correctly',
+ headers: ['Chinese δΈζ', 'Japanese ζ₯ζ¬θͺ', 'Korean νκ΅μ΄'],
+ rows: [
+ ['δ½ ε₯½', 'γγγ«γ‘γ―', 'μλ
νμΈμ'],
+ ['δΈη', 'δΈη', 'μΈκ³'],
+ ],
+ terminalWidth: 60,
+ expected: ['Chinese δΈζ', 'δ½ ε₯½', 'γγγ«γ‘γ―'],
+ },
+ {
+ name: 'renders a table with mixed emojis, Asian characters, and text correctly',
+ headers: ['Mixed π δΈζ', 'Complex π ζ₯ζ¬θͺ', 'Text π νκ΅μ΄'],
+ rows: [
+ ['δ½ ε₯½ π', 'γγγ«γ‘γ― π', 'μλ
νμΈμ π'],
+ ['World π', 'Code π»', 'Pizza π'],
+ ],
+ terminalWidth: 80,
+ expected: ['Mixed π δΈζ', 'δ½ ε₯½ π', 'γγγ«γ‘γ― π'],
+ },
+ ])('$name', ({ headers, rows, terminalWidth, expected }) => {
+ const { lastFrame } = renderWithProviders(
+ ,
+ { width: terminalWidth },
+ );
+
+ const output = lastFrame();
+ expected.forEach((text) => {
+ expect(output).toContain(text);
+ });
+ expect(output).toMatchSnapshot();
+ });
});
diff --git a/packages/cli/src/ui/utils/TableRenderer.tsx b/packages/cli/src/ui/utils/TableRenderer.tsx
index 75ad12eebf..c94e5c18a7 100644
--- a/packages/cli/src/ui/utils/TableRenderer.tsx
+++ b/packages/cli/src/ui/utils/TableRenderer.tsx
@@ -4,10 +4,19 @@
* SPDX-License-Identifier: Apache-2.0
*/
-import React from 'react';
+import React, { useMemo } from 'react';
import { Text, Box } from 'ink';
+import {
+ type StyledChar,
+ toStyledCharacters,
+ styledCharsToString,
+ styledCharsWidth,
+ wordBreakStyledChars,
+ wrapStyledChars,
+ widestLineFromStyledChars,
+} from 'ink';
import { theme } from '../semantic-colors.js';
-import { RenderInline, getPlainTextLength } from './InlineMarkdownRenderer.js';
+import { RenderInline } from './InlineMarkdownRenderer.js';
interface TableRendererProps {
headers: string[];
@@ -15,6 +24,26 @@ interface TableRendererProps {
terminalWidth: number;
}
+const MIN_COLUMN_WIDTH = 5;
+const COLUMN_PADDING = 2;
+const TABLE_MARGIN = 2;
+
+const calculateWidths = (text: string) => {
+ const styledChars = toStyledCharacters(text);
+ const contentWidth = styledCharsWidth(styledChars);
+
+ const words: StyledChar[][] = wordBreakStyledChars(styledChars);
+ const maxWordWidth = widestLineFromStyledChars(words);
+
+ return { contentWidth, maxWordWidth };
+};
+
+// Used to reduce redundant parsing and cache the widths for each line
+interface ProcessedLine {
+ text: string;
+ width: number;
+}
+
/**
* Custom table renderer for markdown tables
* We implement our own instead of using ink-table due to module compatibility issues
@@ -24,89 +53,146 @@ export const TableRenderer: React.FC = ({
rows,
terminalWidth,
}) => {
- // Calculate column widths using actual display width after markdown processing
- const columnWidths = headers.map((header, index) => {
- const headerWidth = getPlainTextLength(header);
- const maxRowWidth = Math.max(
- ...rows.map((row) => getPlainTextLength(row[index] || '')),
+ // Clean headers: remove bold markers since we already render headers as bold
+ // and having them can break wrapping when the markers are split across lines.
+ const cleanedHeaders = useMemo(
+ () => headers.map((header) => header.replace(/\*\*(.*?)\*\*/g, '$1')),
+ [headers],
+ );
+
+ const { wrappedHeaders, wrappedRows, adjustedWidths } = useMemo(() => {
+ // --- Define Constraints per Column ---
+ const constraints = cleanedHeaders.map((header, colIndex) => {
+ let { contentWidth: maxContentWidth, maxWordWidth } =
+ calculateWidths(header);
+
+ rows.forEach((row) => {
+ const cell = row[colIndex] || '';
+ const { contentWidth: cellWidth, maxWordWidth: cellWordWidth } =
+ calculateWidths(cell);
+
+ maxContentWidth = Math.max(maxContentWidth, cellWidth);
+ maxWordWidth = Math.max(maxWordWidth, cellWordWidth);
+ });
+
+ const minWidth = maxWordWidth;
+ const maxWidth = Math.max(minWidth, maxContentWidth);
+
+ return { minWidth, maxWidth };
+ });
+
+ // --- Calculate Available Space ---
+ // Fixed overhead: borders (n+1) + padding (2n)
+ const fixedOverhead =
+ cleanedHeaders.length + 1 + cleanedHeaders.length * COLUMN_PADDING;
+ const availableWidth = Math.max(
+ 0,
+ terminalWidth - fixedOverhead - TABLE_MARGIN,
);
- return Math.max(headerWidth, maxRowWidth) + 2; // Add padding
- });
- // Ensure table fits within terminal width
- // We calculate scale based on content width vs available width (terminal - borders)
- // First, extract content widths by removing the 2-char padding.
- const contentWidths = columnWidths.map((width) => Math.max(0, width - 2));
- const totalContentWidth = contentWidths.reduce(
- (sum, width) => sum + width,
- 0,
- );
+ // --- Allocation Algorithm ---
+ const totalMinWidth = constraints.reduce((sum, c) => sum + c.minWidth, 0);
+ let finalContentWidths: number[];
- // Fixed overhead includes padding (2 per column) and separators (1 per column + 1 final).
- const fixedOverhead = headers.length * 2 + (headers.length + 1);
+ if (totalMinWidth > availableWidth) {
+ // We must scale all the columns except the ones that are very short(<=5 characters)
+ const shortColumns = constraints.filter(
+ (c) => c.maxWidth <= MIN_COLUMN_WIDTH,
+ );
+ const totalShortColumnWidth = shortColumns.reduce(
+ (sum, c) => sum + c.minWidth,
+ 0,
+ );
- // Subtract 1 from available width to avoid edge-case wrapping on some terminals
- const availableWidth = Math.max(0, terminalWidth - fixedOverhead - 1);
+ const finalTotalShortColumnWidth =
+ totalShortColumnWidth >= availableWidth ? 0 : totalShortColumnWidth;
- const scaleFactor =
- totalContentWidth > availableWidth ? availableWidth / totalContentWidth : 1;
- const adjustedWidths = contentWidths.map(
- (width) => Math.floor(width * scaleFactor) + 2,
- );
-
- // Helper function to render a cell with proper width
- const renderCell = (
- content: string,
- width: number,
- isHeader = false,
- ): React.ReactNode => {
- const contentWidth = Math.max(0, width - 2);
- const displayWidth = getPlainTextLength(content);
-
- let cellContent = content;
- if (displayWidth > contentWidth) {
- if (contentWidth <= 3) {
- // Just truncate by character count
- cellContent = content.substring(
- 0,
- Math.min(content.length, contentWidth),
- );
- } else {
- // Truncate preserving markdown formatting using binary search
- let left = 0;
- let right = content.length;
- let bestTruncated = content;
-
- // Binary search to find the optimal truncation point
- while (left <= right) {
- const mid = Math.floor((left + right) / 2);
- const candidate = content.substring(0, mid);
- const candidateWidth = getPlainTextLength(candidate);
-
- if (candidateWidth <= contentWidth - 1) {
- bestTruncated = candidate;
- left = mid + 1;
- } else {
- right = mid - 1;
- }
+ const scale =
+ (availableWidth - finalTotalShortColumnWidth) /
+ (totalMinWidth - finalTotalShortColumnWidth);
+ finalContentWidths = constraints.map((c) => {
+ if (c.maxWidth <= MIN_COLUMN_WIDTH && finalTotalShortColumnWidth > 0) {
+ return c.minWidth;
}
+ return Math.floor(c.minWidth * scale);
+ });
+ } else {
+ const surplus = availableWidth - totalMinWidth;
+ const totalGrowthNeed = constraints.reduce(
+ (sum, c) => sum + (c.maxWidth - c.minWidth),
+ 0,
+ );
- cellContent = bestTruncated + 'β¦';
+ if (totalGrowthNeed === 0) {
+ finalContentWidths = constraints.map((c) => c.minWidth);
+ } else {
+ finalContentWidths = constraints.map((c) => {
+ const growthNeed = c.maxWidth - c.minWidth;
+ const share = growthNeed / totalGrowthNeed;
+ const extra = Math.floor(surplus * share);
+ return Math.min(c.maxWidth, c.minWidth + extra);
+ });
}
}
- // Calculate exact padding needed
- const actualDisplayWidth = getPlainTextLength(cellContent);
- const paddingNeeded = Math.max(0, contentWidth - actualDisplayWidth);
+ // --- Pre-wrap and Optimize Widths ---
+ const actualColumnWidths = new Array(cleanedHeaders.length).fill(0);
+
+ const wrapAndProcessRow = (row: string[]) => {
+ const rowResult: ProcessedLine[][] = [];
+ row.forEach((cell, colIndex) => {
+ const allocatedWidth = finalContentWidths[colIndex];
+ const contentWidth = Math.max(1, allocatedWidth);
+
+ const contentStyledChars = toStyledCharacters(cell);
+ const wrappedStyledLines = wrapStyledChars(
+ contentStyledChars,
+ contentWidth,
+ );
+
+ const maxLineWidth = widestLineFromStyledChars(wrappedStyledLines);
+ actualColumnWidths[colIndex] = Math.max(
+ actualColumnWidths[colIndex],
+ maxLineWidth,
+ );
+
+ const lines = wrappedStyledLines.map((line) => ({
+ text: styledCharsToString(line),
+ width: styledCharsWidth(line),
+ }));
+ rowResult.push(lines);
+ });
+ return rowResult;
+ };
+
+ const wrappedHeaders = wrapAndProcessRow(cleanedHeaders);
+ const wrappedRows = rows.map((row) => wrapAndProcessRow(row));
+
+ // Use the TIGHTEST widths that fit the wrapped content + padding
+ const adjustedWidths = actualColumnWidths.map((w) => w + COLUMN_PADDING);
+
+ return { wrappedHeaders, wrappedRows, adjustedWidths };
+ }, [cleanedHeaders, rows, terminalWidth]);
+
+ // Helper function to render a cell with proper width
+ const renderCell = (
+ content: ProcessedLine,
+ width: number,
+ isHeader = false,
+ ): React.ReactNode => {
+ const contentWidth = Math.max(0, width - COLUMN_PADDING);
+ // Use pre-calculated width to avoid re-parsing
+ const displayWidth = content.width;
+ const paddingNeeded = Math.max(0, contentWidth - displayWidth);
return (
{isHeader ? (
-
+
) : (
-
+
)}
{' '.repeat(paddingNeeded)}
@@ -128,11 +214,14 @@ export const TableRenderer: React.FC = ({
return {border};
};
- // Helper function to render a table row
- const renderRow = (cells: string[], isHeader = false): React.ReactNode => {
+ // Helper function to render a single visual line of a row
+ const renderVisualRow = (
+ cells: ProcessedLine[],
+ isHeader = false,
+ ): React.ReactNode => {
const renderedCells = cells.map((cell, index) => {
const width = adjustedWidths[index] || 0;
- return renderCell(cell || '', width, isHeader);
+ return renderCell(cell, width, isHeader);
});
return (
@@ -151,21 +240,46 @@ export const TableRenderer: React.FC = ({
);
};
+ // Handles the wrapping logic for a logical data row
+ const renderDataRow = (
+ wrappedCells: ProcessedLine[][],
+ rowIndex?: number,
+ isHeader = false,
+ ): React.ReactNode => {
+ const key = isHeader ? 'header' : `${rowIndex}`;
+ const maxHeight = Math.max(...wrappedCells.map((lines) => lines.length), 1);
+
+ const visualRows: React.ReactNode[] = [];
+ for (let i = 0; i < maxHeight; i++) {
+ const visualRowCells = wrappedCells.map(
+ (lines) => lines[i] || { text: '', width: 0 },
+ );
+ visualRows.push(
+
+ {renderVisualRow(visualRowCells, isHeader)}
+ ,
+ );
+ }
+
+ return {visualRows};
+ };
+
return (
{/* Top border */}
{renderBorder('top')}
- {/* Header row */}
- {renderRow(headers, true)}
+ {/*
+ Header row
+ Keep the rowIndex as -1 to differentiate from data rows
+ */}
+ {renderDataRow(wrappedHeaders, -1, true)}
{/* Middle border */}
{renderBorder('middle')}
{/* Data rows */}
- {rows.map((row, index) => (
- {renderRow(row)}
- ))}
+ {wrappedRows.map((row, index) => renderDataRow(row, index))}
{/* Bottom border */}
{renderBorder('bottom')}
diff --git a/packages/cli/src/ui/utils/__snapshots__/TableRenderer.test.tsx.snap b/packages/cli/src/ui/utils/__snapshots__/TableRenderer.test.tsx.snap
index 0f9e0b84d5..c565b0c206 100644
--- a/packages/cli/src/ui/utils/__snapshots__/TableRenderer.test.tsx.snap
+++ b/packages/cli/src/ui/utils/__snapshots__/TableRenderer.test.tsx.snap
@@ -1,5 +1,63 @@
// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+exports[`TableRenderer > 'handles non-ASCII characters (emojis β¦' 1`] = `
+"
+ββββββββββββββββ¬βββββββββββββ¬ββββββββββββββββ
+β Emoji π β Asian ζ±ε β Mixed π Text β
+ββββββββββββββββΌβββββββββββββΌββββββββββββββββ€
+β Start π End β δ½ ε₯½δΈη β Rocket π Man β
+β Thumbs π Up β γγγ«γ‘γ― β Fire π₯ β
+ββββββββββββββββ΄βββββββββββββ΄ββββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > 'renders a table with mixed emojis, Asβ¦' 1`] = `
+"
+βββββββββββββββββ¬ββββββββββββββββββββ¬βββββββββββββββββ
+β Mixed π δΈζ β Complex π ζ₯ζ¬θͺ β Text π νκ΅μ΄ β
+βββββββββββββββββΌββββββββββββββββββββΌβββββββββββββββββ€
+β δ½ ε₯½ π β γγγ«γ‘γ― π β μλ
νμΈμ π β
+β World π β Code π» β Pizza π β
+βββββββββββββββββ΄ββββββββββββββββββββ΄βββββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > 'renders a table with only Asian charaβ¦' 1`] = `
+"
+ββββββββββββββββ¬ββββββββββββββββββ¬ββββββββββββββββ
+β Chinese δΈζ β Japanese ζ₯ζ¬θͺ β Korean νκ΅μ΄ β
+ββββββββββββββββΌββββββββββββββββββΌββββββββββββββββ€
+β δ½ ε₯½ β γγγ«γ‘γ― β μλ
νμΈμ β
+β δΈη β δΈη β μΈκ³ β
+ββββββββββββββββ΄ββββββββββββββββββ΄ββββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > 'renders a table with only emojis and β¦' 1`] = `
+"
+ββββββββββββ¬ββββββββββββ¬βββββββββββ
+β Happy π β Rocket π β Heart β€οΈ β
+ββββββββββββΌββββββββββββΌβββββββββββ€
+β Smile π β Fire π₯ β Love π β
+β Cool π β Star β β Blue π β
+ββββββββββββ΄ββββββββββββ΄βββββββββββ
+"
+`;
+
+exports[`TableRenderer > handles wrapped bold headers without showing markers 1`] = `
+"
+βββββββββββββββ¬ββββββββ¬ββββββββββ
+β Very Long β Short β Another β
+β Bold Header β β Long β
+β That Will β β Header β
+β Wrap β β β
+βββββββββββββββΌββββββββΌββββββββββ€
+β Data 1 β Data β Data 3 β
+β β 2 β β
+βββββββββββββββ΄ββββββββ΄ββββββββββ
+"
+`;
+
exports[`TableRenderer > renders a 3x3 table correctly 1`] = `
"
ββββββββββββββββ¬βββββββββββββββ¬βββββββββββββββ
@@ -12,14 +70,117 @@ exports[`TableRenderer > renders a 3x3 table correctly 1`] = `
"
`;
-exports[`TableRenderer > renders a table with long headers and 4 columns correctly 1`] = `
+exports[`TableRenderer > renders a complex table with mixed content lengths correctly 1`] = `
"
-ββββββββββββββββββββ¬βββββββββββββββββββ¬ββββββββββββββββββββ¬βββββββββββββββββββ
-β Very Long Columβ¦ β Very Long Columβ¦ β Very Long Columnβ¦ β Very Long Columβ¦ β
-ββββββββββββββββββββΌβββββββββββββββββββΌββββββββββββββββββββΌβββββββββββββββββββ€
-β Data 1.1 β Data 1.2 β Data 1.3 β Data 1.4 β
-β Data 2.1 β Data 2.2 β Data 2.3 β Data 2.4 β
-β Data 3.1 β Data 3.2 β Data 3.3 β Data 3.4 β
-ββββββββββββββββββββ΄βββββββββββββββββββ΄ββββββββββββββββββββ΄βββββββββββββββββββ
+βββββββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββββ¬ββββββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββββ¬ββββββ¬βββββββββ¬ββββββββββ¬ββββββββ
+β Comprehensive Architectural β Implementation Details for β Longitudinal Performance β Strategic Security Framework β Key β Status β Version β Owner β
+β Specification for the β the High-Throughput β Analysis Across β for Mitigating Sophisticated β β β β β
+β Distributed Infrastructure β Asynchronous Message β Multi-Regional Cloud β Cross-Site Scripting β β β β β
+β Layer β Processing Pipeline with β Deployment Clusters β Vulnerabilities β β β β β
+β β Extended Scalability β β β β β β β
+β β Features and Redundancy β β β β β β β
+β β Protocols β β β β β β β
+βββββββββββββββββββββββββββββββΌβββββββββββββββββββββββββββββββΌββββββββββββββββββββββββββββββΌβββββββββββββββββββββββββββββββΌββββββΌβββββββββΌββββββββββΌββββββββ€
+β The primary architecture β Each message is processed β Historical data indicates a β A multi-layered defense β INF β Active β v2.4 β J. β
+β utilizes a decoupled β through a series of β significant reduction in β strategy incorporates β β β β Doe β
+β microservices approach, β specialized workers that β tail latency when utilizing β content security policies, β β β β β
+β leveraging container β handle data transformation, β edge computing nodes closer β input sanitization β β β β β
+β orchestration for β validation, and persistent β to the geographic location β libraries, and regular β β β β β
+β scalability and fault β storage using a persistent β of the end-user base. β automated penetration β β β β β
+β tolerance in high-load β queue. β β testing routines. β β β β β
+β scenarios. β β Monitoring tools have β β β β β β
+β β The pipeline features β captured a steady increase β Developers are required to β β β β β
+β This layer provides the β built-in retry mechanisms β in throughput efficiency β undergo mandatory security β β β β β
+β fundamental building blocks β with exponential backoff to β since the introduction of β training focusing on the β β β β β
+β for service discovery, load β ensure message delivery β the vectorized query engine β OWASP Top Ten to ensure that β β β β β
+β balancing, and β integrity even during β in the primary data β security is integrated into β β β β β
+β inter-service communication β transient network or service β warehouse. β the initial design phase. β β β β β
+β via highly efficient β failures. β β β β β β β
+β protocol buffers. β β Resource utilization β The implementation of a β β β β β
+β β Horizontal autoscaling is β metrics demonstrate that β robust Identity and Access β β β β β
+β Advanced telemetry and β triggered automatically β the transition to β Management system ensures β β β β β
+β logging integrations allow β based on the depth of the β serverless compute for β that the principle of least β β β β β
+β for real-time monitoring of β processing queue, ensuring β intermittent tasks has β privilege is strictly β β β β β
+β system health and rapid β consistent performance β resulted in a thirty β enforced across all β β β β β
+β identification of β during unexpected traffic β percent cost optimization. β environments. β β β β β
+β bottlenecks within the β spikes. β β β β β β β
+β service mesh. β β β β β β β β
+βββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββ΄ββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββ΄ββββββ΄βββββββββ΄ββββββββββ΄ββββββββ
+"
+`;
+
+exports[`TableRenderer > renders a table with long headers and 4 columns correctly 1`] = `
+"
+βββββββββββββββββ¬ββββββββββββββββ¬βββββββββββββββββββ¬βββββββββββββββββββ
+β Very Long β Very Long β Very Long Column β Very Long Column β
+β Column Header β Column Header β Header Three β Header Four β
+β One β Two β β β
+βββββββββββββββββΌββββββββββββββββΌβββββββββββββββββββΌβββββββββββββββββββ€
+β Data 1.1 β Data 1.2 β Data 1.3 β Data 1.4 β
+β Data 2.1 β Data 2.2 β Data 2.3 β Data 2.4 β
+β Data 3.1 β Data 3.2 β Data 3.3 β Data 3.4 β
+βββββββββββββββββ΄ββββββββββββββββ΄βββββββββββββββββββ΄βββββββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > strips bold markers from headers and renders them correctly 1`] = `
+"
+βββββββββββββββ¬ββββββββββββββββ¬βββββββββββββββ
+β Bold Header β Normal Header β Another Bold β
+βββββββββββββββΌββββββββββββββββΌβββββββββββββββ€
+β Data 1 β Data 2 β Data 3 β
+βββββββββββββββ΄ββββββββββββββββ΄βββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > wraps all long columns correctly 1`] = `
+"
+ββββββββββββββββββ¬βββββββββββββββββ¬ββββββββββββββββββ
+β Col 1 β Col 2 β Col 3 β
+ββββββββββββββββββΌβββββββββββββββββΌββββββββββββββββββ€
+β This is a very β This is also a β And this is the β
+β long text that β very long text β third long text β
+β needs wrapping β that needs β that needs β
+β in column 1 β wrapping in β wrapping in β
+β β column 2 β column 3 β
+ββββββββββββββββββ΄βββββββββββββββββ΄ββββββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > wraps columns with punctuation correctly 1`] = `
+"
+βββββββββββββββββββββ¬ββββββββββββββββ¬ββββββββββββββββββ
+β Punctuation 1 β Punctuation 2 β Punctuation 3 β
+βββββββββββββββββββββΌββββββββββββββββΌββββββββββββββββββ€
+β Start. Stop. β Semi; colon: β At@ Hash# β
+β Comma, separated. β Pipe| Slash/ β Dollar$ β
+β Exclamation! β Backslash\\ β Percent% Caret^ β
+β Question? β β Ampersand& β
+β hyphen-ated β β Asterisk* β
+βββββββββββββββββββββ΄ββββββββββββββββ΄ββββββββββββββββββ
+"
+`;
+
+exports[`TableRenderer > wraps long cell content correctly 1`] = `
+"
+βββββββββ¬ββββββββββββββββββββββββββββββ¬ββββββββ
+β Col 1 β Col 2 β Col 3 β
+βββββββββΌββββββββββββββββββββββββββββββΌββββββββ€
+β Short β This is a very long cell β Short β
+β β content that should wrap to β β
+β β multiple lines β β
+βββββββββ΄ββββββββββββββββββββββββββββββ΄ββββββββ
+"
+`;
+
+exports[`TableRenderer > wraps mixed long and short columns correctly 1`] = `
+"
+βββββββββ¬βββββββββββββββββββββββββββ¬βββββββββ
+β Short β Long β Medium β
+βββββββββΌβββββββββββββββββββββββββββΌβββββββββ€
+β Tiny β This is a very long text β Not so β
+β β that definitely needs to β long β
+β β wrap to the next line β β
+βββββββββ΄βββββββββββββββββββββββββββ΄βββββββββ
"
`;