bsprof-cli 1.0.0

package/dist/formatter/ChromeTraceExporter.js

@@ -0,0 +1,106 @@
+import { BsprofParser } from '../parser/BsprofParser.js';
+/**
+ * Export profiling data to Chrome DevTools Trace Event format.
+ * Viewable in chrome://tracing or https://ui.perfetto.dev
+ *
+ * Each CPU measurement becomes a Complete ("X") event with duration.
+ * Thread/module structure is preserved via pid/tid mapping.
+ */
+export class ChromeTraceExporter {
+    export(profile) {
+        const events = [];
+        const { cpuByPE } = profile.parseResult;
+        // Map module names to numeric pids, thread IDs
+        const moduleIds = new Map();
+        let nextPid = 1;
+        // Metadata events for process/thread names
+        const metaEvents = [];
+        let tsAccumulator = 0;
+        // Sort by cpuSelf descending for consistent layout
+        const sortedEntries = [...cpuByPE.entries()].sort((a, b) => b[1].cpuSelf - a[1].cpuSelf);
+        for (const [peId, cpu] of sortedEntries) {
+            if (cpu.cpuSelf <= 0 && cpu.wallSelf <= 0)
+                continue;
+            const mod = BsprofParser.resolveModuleName(profile, peId);
+            const func = BsprofParser.resolveFuncName(profile, peId);
+            const file = BsprofParser.resolveFileName(profile, peId);
+            let pid = moduleIds.get(mod);
+            if (pid === undefined) {
+                pid = nextPid++;
+                moduleIds.set(mod, pid);
+                metaEvents.push({
+                    name: 'process_name',
+                    cat: '__metadata',
+                    ph: 'M',
+                    ts: 0,
+                    pid,
+                    tid: 0,
+                    args: { name: mod },
+                });
+            }
+            // Use wall time for duration (in microseconds)
+            const dur = cpu.wallSelf > 0 ? cpu.wallSelf : cpu.cpuSelf;
+            events.push({
+                name: func,
+                cat: file,
+                ph: 'X',
+                ts: tsAccumulator,
+                dur,
+                pid,
+                tid: 1,
+                args: {
+                    file,
+                    cpuSelf: cpu.cpuSelf,
+                    wallSelf: cpu.wallSelf,
+                    callCount: cpu.callCount || 0,
+                    module: mod,
+                },
+            });
+            tsAccumulator += dur;
+        }
+        // Build call-stack-based flame chart for top entries
+        this.addCallStackEvents(profile, events, moduleIds);
+        const allEvents = [...metaEvents, ...events];
+        return JSON.stringify({ traceEvents: allEvents }, null, 2);
+    }
+    addCallStackEvents(profile, events, moduleIds) {
+        const { cpuByPE } = profile.parseResult;
+        // For entries with significant CPU, reconstruct nested call stacks
+        const topEntries = [...cpuByPE.entries()]
+            .filter(([, cpu]) => cpu.cpuSelf > 0)
+            .sort((a, b) => b[1].cpuSelf - a[1].cpuSelf)
+            .slice(0, 100);
+        let stackTs = events.length > 0 ? (events[events.length - 1].ts ?? 0) + (events[events.length - 1].dur ?? 0) + 1000 : 0;
+        for (const [peId, cpu] of topEntries) {
+            const stack = BsprofParser.resolveCallStack(profile, peId);
+            if (stack.length <= 1)
+                continue;
+            const mod = BsprofParser.resolveModuleName(profile, peId);
+            const pid = moduleIds.get(mod) ?? 1;
+            const totalDur = cpu.wallSelf > 0 ? cpu.wallSelf : cpu.cpuSelf;
+            // Emit nested "B"/"E" events for the call stack (deepest first in stack)
+            for (let i = stack.length - 1; i >= 0; i--) {
+                events.push({
+                    name: stack[i],
+                    cat: 'callstack',
+                    ph: 'B',
+                    ts: stackTs,
+                    pid,
+                    tid: 2,
+                });
+            }
+            for (let i = 0; i < stack.length; i++) {
+                events.push({
+                    name: stack[i],
+                    cat: 'callstack',
+                    ph: 'E',
+                    ts: stackTs + totalDur,
+                    pid,
+                    tid: 2,
+                });
+            }
+            stackTs += totalDur + 100;
+        }
+    }
+}
+//# sourceMappingURL=ChromeTraceExporter.js.map

package/dist/formatter/CsvExporter.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedProfile, AnalysisOptions } from '../parser/types.js';
+export declare class CsvExporter {
+    export(profile: ParsedProfile, options?: Partial<AnalysisOptions>): string;
+}
+//# sourceMappingURL=CsvExporter.d.ts.map

package/dist/formatter/CsvExporter.js

@@ -0,0 +1,32 @@
+import { aggregate } from '../analyzer/Aggregator.js';
+const CSV_HEADER = 'function,file,module,allocBytes,freeBytes,retainedBytes,allocCount,freeCount,cpuSelf,wallSelf,callCount';
+export class CsvExporter {
+    export(profile, options = {}) {
+        const { byFunction } = aggregate(profile, options);
+        const lines = [CSV_HEADER];
+        const sorted = [...byFunction.values()].sort((a, b) => b.retainedBytes - a.retainedBytes);
+        for (const f of sorted) {
+            lines.push([
+                csvEscape(f.function),
+                csvEscape(f.file),
+                csvEscape(f.module),
+                f.allocBytes,
+                f.freeBytes,
+                f.retainedBytes,
+                f.allocCount,
+                f.freeCount,
+                f.cpuSelf,
+                f.wallSelf,
+                f.callCount,
+            ].join(','));
+        }
+        return lines.join('\n');
+    }
+}
+function csvEscape(value) {
+    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+//# sourceMappingURL=CsvExporter.js.map

package/dist/formatter/JsonFormatter.d.ts

@@ -0,0 +1,10 @@
+import type { MemoryReport, CpuReport, FullReport, SummaryReport, DiffReport, HeaderInfo } from '../parser/types.js';
+export declare class JsonFormatter {
+    formatMemoryReport(report: MemoryReport): string;
+    formatCpuReport(report: CpuReport): string;
+    formatFullReport(report: FullReport): string;
+    formatSummaryReport(report: SummaryReport): string;
+    formatDiffReport(report: DiffReport): string;
+    formatInfo(header: HeaderInfo, fileSize: number): string;
+}
+//# sourceMappingURL=JsonFormatter.d.ts.map

package/dist/formatter/JsonFormatter.js

@@ -0,0 +1,21 @@
+export class JsonFormatter {
+    formatMemoryReport(report) {
+        return JSON.stringify(report, null, 2);
+    }
+    formatCpuReport(report) {
+        return JSON.stringify(report, null, 2);
+    }
+    formatFullReport(report) {
+        return JSON.stringify(report, null, 2);
+    }
+    formatSummaryReport(report) {
+        return JSON.stringify(report, null, 2);
+    }
+    formatDiffReport(report) {
+        return JSON.stringify(report, null, 2);
+    }
+    formatInfo(header, fileSize) {
+        return JSON.stringify({ ...header, fileSize }, null, 2);
+    }
+}
+//# sourceMappingURL=JsonFormatter.js.map

package/dist/formatter/MarkdownFormatter.d.ts

@@ -0,0 +1,15 @@
+import type { MemoryReport, CpuReport, FullReport, SummaryReport, DiffReport, HeaderInfo } from '../parser/types.js';
+export declare class MarkdownFormatter {
+    formatMemoryReport(report: MemoryReport): string;
+    formatCpuReport(report: CpuReport): string;
+    formatFullReport(report: FullReport): string;
+    formatSummaryReport(report: SummaryReport): string;
+    formatDiffReport(report: DiffReport): string;
+    formatInfo(header: HeaderInfo, fileSize: number): string;
+    private headerBlock;
+    private moduleTable;
+    private functionTable;
+    private cpuTable;
+    private deltaTable;
+}
+//# sourceMappingURL=MarkdownFormatter.d.ts.map

package/dist/formatter/MarkdownFormatter.js

@@ -0,0 +1,174 @@
+import { fmtBytes, fmtTime, fmtDuration, fmtNum } from './helpers.js';
+export class MarkdownFormatter {
+    formatMemoryReport(report) {
+        const lines = [];
+        lines.push(this.headerBlock(report.header));
+        lines.push('');
+        lines.push('## Memory Summary');
+        lines.push('');
+        lines.push(`| Metric | Value |`);
+        lines.push(`|--------|-------|`);
+        lines.push(`| Total Allocated | ${fmtBytes(report.summary.totalAllocBytes)} |`);
+        lines.push(`| Total Freed | ${fmtBytes(report.summary.totalFreeBytes)} |`);
+        lines.push(`| **Total Retained** | **${fmtBytes(report.summary.totalRetainedBytes)}** |`);
+        lines.push(`| Alloc Count | ${fmtNum(report.summary.totalAllocCount)} |`);
+        lines.push(`| Free Count | ${fmtNum(report.summary.totalFreeCount)} |`);
+        lines.push('');
+        lines.push('## Memory by Module');
+        lines.push('');
+        lines.push(this.moduleTable(report.byModule));
+        lines.push('');
+        lines.push(`## Top ${report.byFunction.length} Functions by Retained Bytes`);
+        lines.push('');
+        lines.push(this.functionTable(report.byFunction));
+        return lines.join('\n');
+    }
+    formatCpuReport(report) {
+        const lines = [];
+        lines.push(this.headerBlock(report.header));
+        lines.push('');
+        lines.push('## CPU Summary');
+        lines.push('');
+        lines.push(`| Metric | Value |`);
+        lines.push(`|--------|-------|`);
+        lines.push(`| Total CPU Time | ${fmtTime(report.summary.totalCpuTime)} |`);
+        lines.push(`| Total Wall Time | ${fmtTime(report.summary.totalWallTime)} |`);
+        lines.push(`| Total Calls | ${fmtNum(report.summary.totalCallCount)} |`);
+        lines.push('');
+        lines.push(`## Top ${report.byFunction.length} Functions by CPU Self Time`);
+        lines.push('');
+        lines.push(this.cpuTable(report.byFunction));
+        return lines.join('\n');
+    }
+    formatFullReport(report) {
+        return this.formatMemoryReport(report.memory) + '\n\n---\n\n' + this.formatCpuReport(report.cpu);
+    }
+    formatSummaryReport(report) {
+        const lines = [];
+        lines.push(this.headerBlock(report.header));
+        lines.push('');
+        lines.push('## Parse Stats');
+        lines.push('');
+        lines.push(`| Metric | Value |`);
+        lines.push(`|--------|-------|`);
+        lines.push(`| Entries | ${fmtNum(report.parseStats.entries)} |`);
+        lines.push(`| Strings | ${fmtNum(report.parseStats.strings)} |`);
+        lines.push(`| Modules | ${fmtNum(report.parseStats.modules)} |`);
+        lines.push(`| Path Elements | ${fmtNum(report.parseStats.pathElements)} |`);
+        lines.push(`| Errors | ${report.parseStats.errors} |`);
+        lines.push('');
+        lines.push('## Module Overview');
+        lines.push('');
+        lines.push(this.moduleTable(report.moduleOverview));
+        if (report.topMemoryLeaks.length > 0) {
+            lines.push('');
+            lines.push('## Top Memory Leaks');
+            lines.push('');
+            lines.push(this.functionTable(report.topMemoryLeaks));
+        }
+        if (report.topCpuConsumers.length > 0) {
+            lines.push('');
+            lines.push('## Top CPU Consumers');
+            lines.push('');
+            lines.push(this.cpuTable(report.topCpuConsumers));
+        }
+        return lines.join('\n');
+    }
+    formatDiffReport(report) {
+        const lines = [];
+        lines.push('# Profile Comparison');
+        lines.push('');
+        lines.push(`- **Before:** ${report.before.file} (${report.before.targetVersion})`);
+        lines.push(`- **After:** ${report.after.file} (${report.after.targetVersion})`);
+        lines.push('');
+        const md = report.memoryDelta;
+        lines.push('## Memory Delta');
+        lines.push('');
+        lines.push(`| Metric | Value |`);
+        lines.push(`|--------|-------|`);
+        lines.push(`| Retained Before | ${fmtBytes(md.totalRetainedBefore)} |`);
+        lines.push(`| Retained After | ${fmtBytes(md.totalRetainedAfter)} |`);
+        lines.push(`| **Delta** | **${fmtBytes(md.totalRetainedDelta)}** |`);
+        lines.push('');
+        if (md.regressions.length > 0) {
+            lines.push('### Regressions');
+            lines.push('');
+            lines.push(this.deltaTable(md.regressions));
+            lines.push('');
+        }
+        if (md.improvements.length > 0) {
+            lines.push('### Improvements');
+            lines.push('');
+            lines.push(this.deltaTable(md.improvements));
+            lines.push('');
+        }
+        if (md.newLeaks.length > 0) {
+            lines.push(`**New Leaks:** ${md.newLeaks.join(', ')}`);
+            lines.push('');
+        }
+        if (md.resolvedLeaks.length > 0) {
+            lines.push(`**Resolved Leaks:** ${md.resolvedLeaks.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    formatInfo(header, fileSize) {
+        const lines = [];
+        lines.push(`# ${header.targetName} ${header.targetVersion}`);
+        lines.push('');
+        lines.push(`| Field | Value |`);
+        lines.push(`|-------|-------|`);
+        lines.push(`| Device | ${header.device} |`);
+        lines.push(`| Firmware | ${header.firmware} |`);
+        lines.push(`| Format | ${header.formatVersion} |`);
+        if (header.duration > 0) {
+            lines.push(`| Duration | ${fmtDuration(header.duration)} |`);
+        }
+        lines.push(`| Size | ${fmtBytes(fileSize)} |`);
+        lines.push(`| Features | ${header.features.join(', ') || 'none'} |`);
+        return lines.join('\n');
+    }
+    headerBlock(header) {
+        return `# ${header.targetName} ${header.targetVersion}\n\n` +
+            `> Device: ${header.device} (${header.firmware}) | Format: ${header.formatVersion} | Size: ${fmtBytes(header.fileSize)}`;
+    }
+    moduleTable(modules) {
+        const lines = [];
+        lines.push('| Module | Alloc | Free | Retained | Allocs# | Frees# |');
+        lines.push('|--------|-------|------|----------|---------|--------|');
+        for (const m of modules) {
+            lines.push(`| ${m.module} | ${fmtBytes(m.allocBytes)} | ${fmtBytes(m.freeBytes)} | ${fmtBytes(m.retainedBytes)} | ${fmtNum(m.allocCount)} | ${fmtNum(m.freeCount)} |`);
+        }
+        return lines.join('\n');
+    }
+    functionTable(funcs) {
+        const lines = [];
+        lines.push('| # | Retained | Alloc | Free | Ops | Calls | CPU Self | Wall Self | Function | File |');
+        lines.push('|---|----------|-------|------|-----|-------|----------|-----------|----------|------|');
+        for (let i = 0; i < funcs.length; i++) {
+            const f = funcs[i];
+            lines.push(`| ${i + 1} | ${fmtBytes(f.retainedBytes)} | ${fmtBytes(f.allocBytes)} | ${fmtBytes(f.freeBytes)} | ${fmtNum(f.allocCount)} | ${f.callCount ? fmtNum(f.callCount) : ''} | ${fmtTime(f.cpuSelf)} | ${fmtTime(f.wallSelf)} | ${f.function} | ${f.file} |`);
+        }
+        return lines.join('\n');
+    }
+    cpuTable(funcs) {
+        const lines = [];
+        lines.push('| # | CPU Self | Wall Self | Calls | Function | File |');
+        lines.push('|---|----------|-----------|-------|----------|------|');
+        for (let i = 0; i < funcs.length; i++) {
+            const f = funcs[i];
+            lines.push(`| ${i + 1} | ${fmtTime(f.cpuSelf)} | ${fmtTime(f.wallSelf)} | ${f.callCount ? fmtNum(f.callCount) : ''} | ${f.function} | ${f.file} |`);
+        }
+        return lines.join('\n');
+    }
+    deltaTable(deltas) {
+        const lines = [];
+        lines.push('| Function | File | Before | After | Delta |');
+        lines.push('|----------|------|--------|-------|-------|');
+        for (const d of deltas) {
+            const sign = d.delta > 0 ? '+' : '';
+            lines.push(`| ${d.function} | ${d.file} | ${fmtBytes(d.retainedBefore)} | ${fmtBytes(d.retainedAfter)} | ${sign}${fmtBytes(d.delta)} |`);
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=MarkdownFormatter.js.map

package/dist/formatter/TextFormatter.d.ts

@@ -0,0 +1,16 @@
+import type { MemoryReport, CpuReport, FullReport, SummaryReport, DiffReport, HeaderInfo } from '../parser/types.js';
+export declare class TextFormatter {
+    formatMemoryReport(report: MemoryReport): string;
+    formatCpuReport(report: CpuReport): string;
+    formatFullReport(report: FullReport): string;
+    formatSummaryReport(report: SummaryReport): string;
+    formatDiffReport(report: DiffReport): string;
+    formatInfo(header: HeaderInfo, fileSize: number): string;
+    private formatHeader;
+    private moduleTable;
+    private fileTable;
+    private functionTable;
+    private cpuFunctionTable;
+    private deltaTable;
+}
+//# sourceMappingURL=TextFormatter.d.ts.map

package/dist/formatter/TextFormatter.js

@@ -0,0 +1,193 @@
+import chalk from 'chalk';
+import { fmtBytes, fmtTime, fmtDuration, fmtNum, pad, padEnd } from './helpers.js';
+export class TextFormatter {
+    formatMemoryReport(report) {
+        const lines = [];
+        lines.push(this.formatHeader(report.header));
+        lines.push('');
+        lines.push(chalk.bold('=== MEMORY SUMMARY ==='));
+        lines.push(`  Total Allocated: ${chalk.cyan(fmtBytes(report.summary.totalAllocBytes))}`);
+        lines.push(`  Total Freed:     ${chalk.green(fmtBytes(report.summary.totalFreeBytes))}`);
+        lines.push(`  Total Retained:  ${chalk.red(fmtBytes(report.summary.totalRetainedBytes))}`);
+        lines.push(`  Alloc Count:     ${fmtNum(report.summary.totalAllocCount)}`);
+        lines.push(`  Free Count:      ${fmtNum(report.summary.totalFreeCount)}`);
+        lines.push(`  Parse Stats:     ${fmtNum(report.summary.parseStats.entries)} entries, ${report.summary.parseStats.errors} errors`);
+        lines.push('');
+        lines.push(chalk.bold('=== MEMORY BY MODULE/THREAD ==='));
+        lines.push(this.moduleTable(report.byModule));
+        lines.push('');
+        lines.push(chalk.bold(`=== TOP ${report.byFile.length} MEMORY BY FILE (retained bytes) ===`));
+        lines.push(this.fileTable(report.byFile));
+        lines.push('');
+        lines.push(chalk.bold(`=== TOP ${report.byFunction.length} MEMORY BY FUNCTION (retained bytes) ===`));
+        lines.push(this.functionTable(report.byFunction));
+        return lines.join('\n');
+    }
+    formatCpuReport(report) {
+        const lines = [];
+        lines.push(this.formatHeader(report.header));
+        lines.push('');
+        lines.push(chalk.bold('=== CPU SUMMARY ==='));
+        lines.push(`  Total CPU Time:  ${chalk.cyan(fmtTime(report.summary.totalCpuTime))}`);
+        lines.push(`  Total Wall Time: ${chalk.cyan(fmtTime(report.summary.totalWallTime))}`);
+        lines.push(`  Total Calls:     ${fmtNum(report.summary.totalCallCount)}`);
+        lines.push('');
+        lines.push(chalk.bold(`=== TOP ${report.byFunction.length} CPU BY FUNCTION ===`));
+        lines.push(this.cpuFunctionTable(report.byFunction));
+        return lines.join('\n');
+    }
+    formatFullReport(report) {
+        const lines = [];
+        lines.push(this.formatMemoryReport(report.memory));
+        lines.push('');
+        lines.push(this.formatCpuReport(report.cpu));
+        return lines.join('\n');
+    }
+    formatSummaryReport(report) {
+        const lines = [];
+        lines.push(this.formatHeader(report.header));
+        lines.push('');
+        lines.push(chalk.bold('=== PARSE STATS ==='));
+        lines.push(`  Entries:       ${fmtNum(report.parseStats.entries)}`);
+        lines.push(`  Strings:       ${fmtNum(report.parseStats.strings)}`);
+        lines.push(`  Modules:       ${fmtNum(report.parseStats.modules)}`);
+        lines.push(`  Path Elements: ${fmtNum(report.parseStats.pathElements)}`);
+        lines.push(`  Errors:        ${report.parseStats.errors}`);
+        lines.push('');
+        lines.push(chalk.bold('=== MODULE OVERVIEW ==='));
+        lines.push(this.moduleTable(report.moduleOverview));
+        lines.push('');
+        if (report.topMemoryLeaks.length > 0) {
+            lines.push(chalk.bold(`=== TOP ${report.topMemoryLeaks.length} MEMORY LEAKS ===`));
+            lines.push(this.functionTable(report.topMemoryLeaks));
+            lines.push('');
+        }
+        if (report.topCpuConsumers.length > 0) {
+            lines.push(chalk.bold(`=== TOP ${report.topCpuConsumers.length} CPU CONSUMERS ===`));
+            lines.push(this.cpuFunctionTable(report.topCpuConsumers));
+        }
+        return lines.join('\n');
+    }
+    formatDiffReport(report) {
+        const lines = [];
+        lines.push(chalk.bold('=== PROFILE COMPARISON ==='));
+        lines.push(`  Before: ${report.before.file} (${report.before.targetVersion})`);
+        lines.push(`  After:  ${report.after.file} (${report.after.targetVersion})`);
+        lines.push('');
+        const md = report.memoryDelta;
+        const deltaColor = md.totalRetainedDelta > 0 ? chalk.red : chalk.green;
+        lines.push(chalk.bold('=== MEMORY DELTA ==='));
+        lines.push(`  Retained Before: ${fmtBytes(md.totalRetainedBefore)}`);
+        lines.push(`  Retained After:  ${fmtBytes(md.totalRetainedAfter)}`);
+        lines.push(`  Delta:           ${deltaColor(fmtBytes(md.totalRetainedDelta))}`);
+        lines.push('');
+        if (md.regressions.length > 0) {
+            lines.push(chalk.bold.red(`  Regressions (${md.regressions.length}):`));
+            lines.push(this.deltaTable(md.regressions));
+            lines.push('');
+        }
+        if (md.improvements.length > 0) {
+            lines.push(chalk.bold.green(`  Improvements (${md.improvements.length}):`));
+            lines.push(this.deltaTable(md.improvements));
+            lines.push('');
+        }
+        if (md.newLeaks.length > 0) {
+            lines.push(chalk.bold.red(`  New Leaks: ${md.newLeaks.join(', ')}`));
+        }
+        if (md.resolvedLeaks.length > 0) {
+            lines.push(chalk.bold.green(`  Resolved Leaks: ${md.resolvedLeaks.join(', ')}`));
+        }
+        if (report.cpuDelta) {
+            const cd = report.cpuDelta;
+            lines.push('');
+            lines.push(chalk.bold('=== CPU DELTA ==='));
+            lines.push(`  CPU Before: ${fmtTime(cd.totalCpuBefore)}`);
+            lines.push(`  CPU After:  ${fmtTime(cd.totalCpuAfter)}`);
+            const cpuDeltaColor = cd.totalCpuDelta > 0 ? chalk.red : chalk.green;
+            lines.push(`  Delta:      ${cpuDeltaColor(fmtTime(cd.totalCpuDelta))}`);
+        }
+        return lines.join('\n');
+    }
+    formatInfo(header, fileSize) {
+        const lines = [];
+        lines.push(`Target:   ${header.targetName} ${header.targetVersion}`);
+        lines.push(`Device:   ${header.device} (${header.firmware})`);
+        lines.push(`Format:   ${header.formatVersion}`);
+        if (header.duration > 0) {
+            lines.push(`Duration: ${fmtDuration(header.duration)}`);
+        }
+        lines.push(`Size:     ${fmtBytes(fileSize)}`);
+        lines.push(`Features: ${header.features.join(', ') || 'none'}`);
+        return lines.join('\n');
+    }
+    formatHeader(header) {
+        return chalk.bold(`=== ${header.targetName} ${header.targetVersion} ===`) + '\n' +
+            `Device: ${header.device} (${header.firmware}) | Format: ${header.formatVersion} | Size: ${fmtBytes(header.fileSize)}`;
+    }
+    moduleTable(modules) {
+        const lines = [];
+        const hdr = `${padEnd('Module', 50)} ${pad('Alloc', 12)} ${pad('Free', 12)} ${pad('Retained', 12)} ${pad('Allocs#', 10)} ${pad('Frees#', 10)}`;
+        lines.push(hdr);
+        lines.push('-'.repeat(hdr.length));
+        for (const m of modules) {
+            const retained = m.retainedBytes;
+            const retStr = retained > 0 ? chalk.red(pad(fmtBytes(retained), 12)) : chalk.green(pad(fmtBytes(retained), 12));
+            lines.push(`${padEnd(m.module, 50)} ${pad(fmtBytes(m.allocBytes), 12)} ${pad(fmtBytes(m.freeBytes), 12)} ${retStr} ${pad(fmtNum(m.allocCount), 10)} ${pad(fmtNum(m.freeCount), 10)}`);
+        }
+        return lines.join('\n');
+    }
+    fileTable(files) {
+        const lines = [];
+        const hdr = `${pad('#', 4)} ${pad('Retained', 12)} ${pad('Alloc', 12)} ${pad('Free', 12)} ${padEnd('Module', 30)} File`;
+        lines.push(hdr);
+        lines.push('-'.repeat(hdr.length + 40));
+        for (let i = 0; i < files.length; i++) {
+            const f = files[i];
+            const retStr = f.retainedBytes > 0 ? chalk.red(pad(fmtBytes(f.retainedBytes), 12)) : pad(fmtBytes(f.retainedBytes), 12);
+            lines.push(`${pad(i + 1, 4)} ${retStr} ${pad(fmtBytes(f.allocBytes), 12)} ${pad(fmtBytes(f.freeBytes), 12)} ${padEnd(f.module || '', 30)} ${f.file}`);
+        }
+        return lines.join('\n');
+    }
+    functionTable(funcs) {
+        const lines = [];
+        const hdr = `${pad('#', 4)} ${pad('Retained', 12)} ${pad('Alloc', 12)} ${pad('Free', 12)} ${pad('Ops', 8)} ${pad('Calls', 8)} ${pad('CPU Self', 10)} ${pad('Wall Self', 10)} Function / File`;
+        lines.push(hdr);
+        lines.push('-'.repeat(hdr.length + 30));
+        for (let i = 0; i < funcs.length; i++) {
+            const f = funcs[i];
+            const retStr = f.retainedBytes > 0 ? chalk.red(pad(fmtBytes(f.retainedBytes), 12)) : pad(fmtBytes(f.retainedBytes), 12);
+            lines.push(`${pad(i + 1, 4)} ${retStr} ${pad(fmtBytes(f.allocBytes), 12)} ${pad(fmtBytes(f.freeBytes), 12)} ${pad(fmtNum(f.allocCount), 8)} ${pad(f.callCount ? fmtNum(f.callCount) : '', 8)} ${pad(fmtTime(f.cpuSelf), 10)} ${pad(fmtTime(f.wallSelf), 10)} ${f.function}  (${f.file})`);
+        }
+        return lines.join('\n');
+    }
+    cpuFunctionTable(funcs) {
+        const lines = [];
+        const hdr = `${pad('#', 4)} ${pad('CPU Self', 12)} ${pad('Wall Self', 12)} ${pad('Calls', 10)} Function / File`;
+        lines.push(hdr);
+        lines.push('-'.repeat(hdr.length + 40));
+        for (let i = 0; i < funcs.length; i++) {
+            const f = funcs[i];
+            lines.push(`${pad(i + 1, 4)} ${pad(fmtTime(f.cpuSelf), 12)} ${pad(fmtTime(f.wallSelf), 12)} ${pad(f.callCount ? fmtNum(f.callCount) : '', 10)} ${f.function}  (${f.file})`);
+            if (f.callStack && f.callStack.length > 1) {
+                for (let j = 1; j < Math.min(f.callStack.length, 6); j++) {
+                    lines.push(`${' '.repeat(6)}${chalk.dim('← ' + f.callStack[j])}`);
+                }
+                if (f.callStack.length > 6) {
+                    lines.push(`${' '.repeat(6)}${chalk.dim(`← ... (${f.callStack.length - 6} more frames)`)}`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    deltaTable(deltas) {
+        const lines = [];
+        for (const d of deltas) {
+            const sign = d.delta > 0 ? '+' : '';
+            const color = d.delta > 0 ? chalk.red : chalk.green;
+            lines.push(`    ${color(sign + fmtBytes(d.delta))} ${d.function} (${d.file})`);
+            lines.push(`      ${fmtBytes(d.retainedBefore)} → ${fmtBytes(d.retainedAfter)}`);
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=TextFormatter.js.map

package/dist/formatter/helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function fmtBytes(n: number): string;
+export declare function fmtTime(us: number): string;
+export declare function fmtDuration(ms: number): string;
+export declare function fmtNum(n: number): string;
+export declare function fmtDate(ms: bigint | number): string;
+export declare function pad(s: string | number, n: number): string;
+export declare function padEnd(s: string | number, n: number): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/formatter/helpers.js

@@ -0,0 +1,44 @@
+export function fmtBytes(n) {
+    if (n < 0)
+        return '-' + fmtBytes(-n);
+    if (n >= 1_048_576)
+        return (n / 1_048_576).toFixed(1) + ' MB';
+    if (n >= 1024)
+        return (n / 1024).toFixed(1) + ' KB';
+    return n + ' B';
+}
+export function fmtTime(us) {
+    if (us < 0)
+        return '-' + fmtTime(-us);
+    if (us >= 1_000_000)
+        return (us / 1_000_000).toFixed(1) + 's';
+    if (us >= 1000)
+        return (us / 1000).toFixed(1) + 'ms';
+    return us + 'us';
+}
+export function fmtDuration(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return `${m}m ${rs}s`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return `${h}h ${rm}m ${rs}s`;
+}
+export function fmtNum(n) {
+    return n.toLocaleString('en-US');
+}
+export function fmtDate(ms) {
+    const d = new Date(Number(ms));
+    return d.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
+}
+export function pad(s, n) {
+    return String(s).padStart(n);
+}
+export function padEnd(s, n) {
+    return String(s).padEnd(n);
+}
+//# sourceMappingURL=helpers.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map