bsprof-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juan Carlos Joya Carvajal
+
+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.

package/README.md

@@ -0,0 +1,238 @@
+# bsprof-cli
+
+CLI tool for parsing and analyzing BrightScript Profiler (`.bsprof`) files from Roku devices.
+
+Supports memory leak detection, CPU hot-path analysis, profile comparison, and multiple export formats including Chrome DevTools traces.
+
+## Getting a .bsprof File
+
+To generate a profiling file from your Roku device:
+
+1. **Enable the profiler** in your app's `manifest` file:
+   ```
+   bs_prof_enabled=true
+   ```
+2. **Sideload and run** your app on the Roku device.
+3. **Download the profile** via the developer console at `http://<roku-ip>:8080` under the Profiler section, or retrieve it programmatically from the device's profiling endpoint.
+
+The resulting `.bsprof` file contains binary-encoded CPU and memory profiling data that this tool decodes and analyzes.
+
+For full details on the file format, see the [Roku BrightScript Profiler specification](https://developer.roku.com/docs/developer-program/dev-tools/brs-profiler-file-format.md).
+
+## Installation
+
+```bash
+npm install -g bsprof-cli
+
+# or run directly
+npx bsprof-cli analyze memory ./profile.bsprof
+```
+
+## Commands
+
+### `bsprof analyze <mode> <file>`
+
+Analyze a `.bsprof` file. Modes:
+
+| Mode | Description |
+|------|-------------|
+| `memory` | Memory allocation analysis -- retained bytes, leak detection |
+| `cpu` | CPU time analysis -- self time, wall time, hot functions |
+| `full` | Combined memory + CPU report |
+| `summary` | One-page overview with key metrics |
+
+```bash
+# Memory analysis with top 20 leaks
+bsprof analyze memory profile.bsprof --top 20
+
+# CPU analysis sorted by wall time, JSON output
+bsprof analyze cpu profile.bsprof --sort wallSelf --format json
+
+# Full report filtered to a specific module
+bsprof analyze full profile.bsprof --filter-module "My App"
+
+# Summary written to a file
+bsprof analyze summary profile.bsprof --output report.txt
+```
+
+#### Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--format <fmt>` | `text` | Output format: `text`, `json`, `markdown` |
+| `--top <n>` | `30` | Number of entries in ranked lists |
+| `--sort <field>` | varies | Sort field: `retained`, `allocated`, `allocCount`, `cpuSelf`, `wallSelf`, `callCount` |
+| `--filter-module <name>` | -- | Filter results to a specific module/thread |
+| `--filter-file <glob>` | -- | Filter results to files matching glob |
+| `--exclude-module <name>` | -- | Exclude a module (e.g. `roku_ads_lib`) |
+| `--threshold <bytes>` | `0` | Only show entries exceeding threshold |
+| `--output <path>` | stdout | Write output to file |
+
+### `bsprof compare <file1> <file2>`
+
+Diff two profiles to detect regressions or verify fixes.
+
+```bash
+bsprof compare before.bsprof after.bsprof
+bsprof compare before.bsprof after.bsprof --format json --output diff.json
+```
+
+Output includes:
+- Delta in retained bytes per function (positive = regression, negative = improvement)
+- New leak sources (functions that appear only in the "after" profile)
+- Resolved leaks (functions in "before" but not "after")
+- CPU time deltas
+
+### `bsprof info <file>`
+
+Print header metadata without full parsing.
+
+```bash
+bsprof info profile.bsprof
+```
+
+```
+Target:   My App v2.0.1
+Device:   Roku Ultra (14.0.0)
+Format:   v3.0.0
+Size:     42.3 MB
+Features: line-specific-data, memory-operations
+```
+
+### `bsprof export <file>`
+
+Export parsed data for external tools.
+
+```bash
+# Chrome DevTools trace (open in chrome://tracing or Perfetto)
+bsprof export profile.bsprof --format chrome-trace --output trace.json
+
+# CSV for spreadsheets
+bsprof export profile.bsprof --format csv --output data.csv
+
+# Full JSON
+bsprof export profile.bsprof --format json --output full.json
+```
+
+| Format | Description |
+|--------|-------------|
+| `chrome-trace` | Chrome DevTools trace (viewable in `chrome://tracing` or Perfetto) |
+| `csv` | Flat CSV for spreadsheet analysis |
+| `json` | Structured JSON with full analysis data |
+
+## Programmatic API
+
+The package also exports a library for use in other tools (e.g. MCP servers):
+
+```typescript
+import { readFileSync } from 'fs';
+import { parseBsprof, analyzeMemory, analyzeCpu, compareBsprof } from 'bsprof-cli';
+
+// Parse raw binary
+const profile = parseBsprof(readFileSync('profile.bsprof'));
+
+// Memory analysis
+const memoryReport = analyzeMemory(profile, { top: 20, sortBy: 'retained' });
+
+// CPU analysis
+const cpuReport = analyzeCpu(profile, { top: 20, sortBy: 'cpuSelf' });
+
+// Compare two profiles
+const before = parseBsprof(readFileSync('before.bsprof'));
+const after = parseBsprof(readFileSync('after.bsprof'));
+const diff = compareBsprof(before, after, 'before.bsprof', 'after.bsprof');
+```
+
+## Example Output
+
+### Memory analysis (`bsprof analyze memory profile.bsprof --top 5`)
+
+```
+=== My Roku App v2.0.1 ===
+Device: Roku Ultra (14.0.0) | Format: v3.0.0 | Size: 42.3 MB
+
+=== MEMORY SUMMARY ===
+  Total Allocated: 93.7 MB
+  Total Freed:     86.9 MB
+  Total Retained:  6.8 MB
+  Alloc Count:     1,240,000
+  Free Count:      1,180,000
+
+=== MEMORY BY MODULE/THREAD ===
+Module                                              Alloc         Free     Retained   Allocs#    Frees#
+------------------------------------------------------------------------------------------------------------------------
+My Roku App                                        50.0 MB      43.7 MB      6.3 MB    800,000   750,000
+roku_ads_lib                                       43.7 MB      43.2 MB    524.3 KB    440,000   430,000
+
+=== TOP 5 MEMORY BY FUNCTION (retained bytes) ===
+   #     Retained        Alloc         Free      Ops    Calls   CPU Self  Wall Self Function / File
+-------------------------------------------------------------------------------------------
+   1      6.6 MB       6.9 MB     307.2 KB   14,000   14,000      0us       0us analytics_track  (pkg:/source/analytics.brs)
+   2    204.8 KB     819.2 KB     614.4 KB    2,000    2,000      0us       0us ui_render_list  (pkg:/source/ui/list.brs)
+   3    102.4 KB     512.0 KB     409.6 KB    1,500    1,500      0us       0us network_fetch  (pkg:/source/net/http.brs)
+   4     51.2 KB     256.0 KB     204.8 KB      800      800      0us       0us parse_response  (pkg:/source/net/parser.brs)
+   5     25.6 KB     128.0 KB     102.4 KB      400      400      0us       0us cache_store  (pkg:/source/cache.brs)
+```
+
+### CPU analysis (`bsprof analyze cpu profile.bsprof --top 3`)
+
+```
+=== TOP 3 CPU BY FUNCTION ===
+   #     CPU Self    Wall Self      Calls Function / File
+----------------------------------------------------------------
+   1        1.2s        3.4s      14,000 analytics_track  (pkg:/source/analytics.brs)
+      ← init_analytics (pkg:/source/main.brs:42)
+      ← main (pkg:/source/main.brs:10)
+   2      800.0ms       2.1s       2,000 ui_render_list  (pkg:/source/ui/list.brs)
+      ← on_focus (pkg:/source/ui/screen.brs:88)
+   3      450.0ms       1.8s       1,500 network_fetch  (pkg:/source/net/http.brs)
+```
+
+CPU output includes reconstructed call stacks showing the caller chain for each hot function.
+
+## Architecture
+
+```
+src/
+├── parser/
+│   ├── types.ts             # Shared interfaces (ParsedProfile, reports, etc.)
+│   ├── varint.ts            # LEB128 varint decoder / buffer reader
+│   └── BsprofParser.ts      # Core binary parser for the .bsprof format
+├── analyzer/
+│   ├── common.ts            # Header info / parse stats builders
+│   ├── Aggregator.ts        # Group-by module/file/function with filtering
+│   ├── MemoryAnalyzer.ts    # Retained bytes, leak detection
+│   ├── CpuAnalyzer.ts       # Self-time ranking, call-path reconstruction
+│   └── DiffAnalyzer.ts      # Two-profile comparison (regressions/improvements)
+├── formatter/
+│   ├── helpers.ts           # Formatting utils (bytes, time, numbers)
+│   ├── TextFormatter.ts     # Colored terminal tables
+│   ├── JsonFormatter.ts     # Structured JSON output
+│   ├── MarkdownFormatter.ts # Markdown tables
+│   ├── ChromeTraceExporter.ts  # Chrome DevTools trace format
+│   └── CsvExporter.ts       # Flat CSV export
+├── index.ts                 # CLI entry point (commander)
+└── lib.ts                   # Programmatic API for library consumers
+```
+
+Data flows through three layers:
+
+1. **Parser** -- reads the binary `.bsprof` file and produces a `ParsedProfile` with raw maps of strings, modules, path elements, memory records, and CPU records.
+2. **Analyzers** -- aggregate the raw data by module/file/function, apply filters, compute retained bytes, detect leaks, rank hot paths, and diff two profiles.
+3. **Formatters** -- render analysis results as terminal text (with colors), JSON, Markdown, Chrome traces, or CSV.
+
+## .bsprof Format
+
+This tool parses the BrightScript Profiler binary format (v3.0.0) as specified in the [Roku developer documentation](https://developer.roku.com/docs/developer-program/dev-tools/brs-profiler-file-format.md).
+
+Supported entry types:
+- String table entries
+- Executable module entries
+- Path elements (root and chained)
+- Memory operations (alloc, free, free_realloc) with address tracking
+- CPU measurements (cpu cycles, wall clock time)
+- Path call count entries
+
+## License
+
+MIT

package/dist/analyzer/Aggregator.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedProfile, AnalysisOptions, ModuleStats, FileStats, FunctionStats } from '../parser/types.js';
+export interface AggregatedData {
+    byModule: Map<string, ModuleStats>;
+    byFile: Map<string, FileStats>;
+    byFunction: Map<string, FunctionStats>;
+}
+export declare function aggregate(profile: ParsedProfile, options?: Partial<AnalysisOptions>): AggregatedData;
+/** Sort and slice function stats for ranked output */
+export declare function rankFunctions(funcs: FunctionStats[], sortBy: string, top: number, threshold?: number): FunctionStats[];
+//# sourceMappingURL=Aggregator.d.ts.map

package/dist/analyzer/Aggregator.js

@@ -0,0 +1,120 @@
+import { minimatch } from 'minimatch';
+import { BsprofParser } from '../parser/BsprofParser.js';
+export function aggregate(profile, options) {
+    const byModule = new Map();
+    const byFile = new Map();
+    const byFunction = new Map();
+    const { memoryByPE, cpuByPE } = profile.parseResult;
+    // Aggregate memory data
+    for (const [peId, rec] of memoryByPE) {
+        const mod = BsprofParser.resolveModuleName(profile, peId);
+        const file = BsprofParser.resolveFileName(profile, peId);
+        const func = BsprofParser.resolveFuncName(profile, peId);
+        if (!passesFilter(mod, file, options))
+            continue;
+        accumulateModule(byModule, mod, rec.allocBytes, rec.freeBytes, rec.allocCount, rec.freeCount);
+        accumulateFile(byFile, file, mod, rec.allocBytes, rec.freeBytes, rec.allocCount, rec.freeCount);
+        accumulateFunction(byFunction, func, file, mod, peId, profile, rec.allocBytes, rec.freeBytes, rec.allocCount, rec.freeCount, 0, 0, 0);
+    }
+    // Aggregate CPU data
+    for (const [peId, cpu] of cpuByPE) {
+        const mod = BsprofParser.resolveModuleName(profile, peId);
+        const file = BsprofParser.resolveFileName(profile, peId);
+        const func = BsprofParser.resolveFuncName(profile, peId);
+        if (!passesFilter(mod, file, options))
+            continue;
+        const fnKey = `${func}|${file}`;
+        let fnRec = byFunction.get(fnKey);
+        if (!fnRec) {
+            fnRec = makeFunctionStats(func, file, mod);
+            byFunction.set(fnKey, fnRec);
+        }
+        fnRec.cpuSelf += cpu.cpuSelf;
+        fnRec.wallSelf += cpu.wallSelf;
+        if (cpu.callCount)
+            fnRec.callCount += cpu.callCount;
+    }
+    return { byModule, byFile, byFunction };
+}
+function passesFilter(mod, file, options) {
+    if (!options)
+        return true;
+    if (options.filterModule && mod !== options.filterModule)
+        return false;
+    if (options.excludeModule && mod === options.excludeModule)
+        return false;
+    if (options.filterFile && !minimatch(file, options.filterFile))
+        return false;
+    return true;
+}
+function accumulateModule(map, mod, allocBytes, freeBytes, allocCount, freeCount) {
+    let rec = map.get(mod);
+    if (!rec) {
+        rec = { module: mod, allocBytes: 0, freeBytes: 0, retainedBytes: 0, allocCount: 0, freeCount: 0 };
+        map.set(mod, rec);
+    }
+    rec.allocBytes += allocBytes;
+    rec.freeBytes += freeBytes;
+    rec.retainedBytes = rec.allocBytes - rec.freeBytes;
+    rec.allocCount += allocCount;
+    rec.freeCount += freeCount;
+}
+function accumulateFile(map, file, mod, allocBytes, freeBytes, allocCount, freeCount) {
+    let rec = map.get(file);
+    if (!rec) {
+        rec = { file, module: mod, allocBytes: 0, freeBytes: 0, retainedBytes: 0, allocCount: 0, freeCount: 0 };
+        map.set(file, rec);
+    }
+    rec.allocBytes += allocBytes;
+    rec.freeBytes += freeBytes;
+    rec.retainedBytes = rec.allocBytes - rec.freeBytes;
+    rec.allocCount += allocCount;
+    rec.freeCount += freeCount;
+}
+function makeFunctionStats(func, file, mod) {
+    return {
+        function: func, file, module: mod,
+        allocBytes: 0, freeBytes: 0, retainedBytes: 0,
+        allocCount: 0, freeCount: 0,
+        cpuSelf: 0, wallSelf: 0, callCount: 0,
+    };
+}
+function accumulateFunction(map, func, file, mod, _peId, _profile, allocBytes, freeBytes, allocCount, freeCount, cpuSelf, wallSelf, callCount) {
+    const key = `${func}|${file}`;
+    let rec = map.get(key);
+    if (!rec) {
+        rec = makeFunctionStats(func, file, mod);
+        map.set(key, rec);
+    }
+    rec.allocBytes += allocBytes;
+    rec.freeBytes += freeBytes;
+    rec.retainedBytes = rec.allocBytes - rec.freeBytes;
+    rec.allocCount += allocCount;
+    rec.freeCount += freeCount;
+    rec.cpuSelf += cpuSelf;
+    rec.wallSelf += wallSelf;
+    rec.callCount += callCount;
+}
+/** Sort and slice function stats for ranked output */
+export function rankFunctions(funcs, sortBy, top, threshold = 0) {
+    const sorted = [...funcs].sort((a, b) => {
+        switch (sortBy) {
+            case 'retained': return b.retainedBytes - a.retainedBytes;
+            case 'allocated': return b.allocBytes - a.allocBytes;
+            case 'allocCount': return b.allocCount - a.allocCount;
+            case 'cpuSelf': return b.cpuSelf - a.cpuSelf;
+            case 'wallSelf': return b.wallSelf - a.wallSelf;
+            case 'callCount': return b.callCount - a.callCount;
+            default: return b.retainedBytes - a.retainedBytes;
+        }
+    });
+    const filtered = threshold > 0
+        ? sorted.filter(f => {
+            if (sortBy === 'cpuSelf' || sortBy === 'wallSelf')
+                return f.cpuSelf >= threshold;
+            return f.retainedBytes >= threshold;
+        })
+        : sorted;
+    return filtered.slice(0, top);
+}
+//# sourceMappingURL=Aggregator.js.map

package/dist/analyzer/CpuAnalyzer.d.ts

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

package/dist/analyzer/CpuAnalyzer.js

@@ -0,0 +1,59 @@
+import { aggregate, rankFunctions } from './Aggregator.js';
+import { buildHeaderInfo, buildParseStats } from './common.js';
+import { BsprofParser } from '../parser/BsprofParser.js';
+export function analyzeCpu(profile, options = {}) {
+    const top = options.top ?? 30;
+    const sortBy = options.sortBy ?? 'cpuSelf';
+    const threshold = options.threshold ?? 0;
+    const { byFunction } = aggregate(profile, options);
+    const allFuncs = [...byFunction.values()].filter(f => f.cpuSelf > 0 || f.wallSelf > 0 || f.callCount > 0);
+    // Attach call stacks for top functions
+    const ranked = rankFunctions(allFuncs, sortBy, top, threshold);
+    attachCallStacks(ranked, profile);
+    const summary = buildCpuSummary(allFuncs, profile);
+    return {
+        header: buildHeaderInfo(profile),
+        summary,
+        byFunction: ranked,
+    };
+}
+function buildCpuSummary(funcs, profile) {
+    let totalCpuTime = 0;
+    let totalWallTime = 0;
+    let totalCallCount = 0;
+    for (const f of funcs) {
+        totalCpuTime += f.cpuSelf;
+        totalWallTime += f.wallSelf;
+        totalCallCount += f.callCount;
+    }
+    return {
+        totalCpuTime,
+        totalWallTime,
+        totalCallCount,
+        parseStats: buildParseStats(profile),
+    };
+}
+/**
+ * For each ranked function, find a representative path element ID and resolve
+ * its call stack by walking the path element chain.
+ */
+function attachCallStacks(funcs, profile) {
+    // Build a reverse index: "func|file" -> peId
+    const funcFileTopeId = new Map();
+    for (const [peId] of profile.parseResult.cpuByPE) {
+        const func = BsprofParser.resolveFuncName(profile, peId);
+        const file = BsprofParser.resolveFileName(profile, peId);
+        const key = `${func}|${file}`;
+        if (!funcFileTopeId.has(key)) {
+            funcFileTopeId.set(key, peId);
+        }
+    }
+    for (const f of funcs) {
+        const key = `${f.function}|${f.file}`;
+        const peId = funcFileTopeId.get(key);
+        if (peId !== undefined) {
+            f.callStack = BsprofParser.resolveCallStack(profile, peId);
+        }
+    }
+}
+//# sourceMappingURL=CpuAnalyzer.js.map

package/dist/analyzer/DiffAnalyzer.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedProfile, AnalysisOptions, DiffReport } from '../parser/types.js';
+export declare function compareBsprof(before: ParsedProfile, after: ParsedProfile, beforeFile: string, afterFile: string, options?: Partial<AnalysisOptions>): DiffReport;
+//# sourceMappingURL=DiffAnalyzer.d.ts.map

package/dist/analyzer/DiffAnalyzer.js

@@ -0,0 +1,114 @@
+import { aggregate } from './Aggregator.js';
+export function compareBsprof(before, after, beforeFile, afterFile, options = {}) {
+    const aggBefore = aggregate(before, options);
+    const aggAfter = aggregate(after, options);
+    const funcsBefore = new Map();
+    for (const f of aggBefore.byFunction.values()) {
+        funcsBefore.set(`${f.function}|${f.file}`, f);
+    }
+    const funcsAfter = new Map();
+    for (const f of aggAfter.byFunction.values()) {
+        funcsAfter.set(`${f.function}|${f.file}`, f);
+    }
+    const allKeys = new Set([...funcsBefore.keys(), ...funcsAfter.keys()]);
+    const memRegressions = [];
+    const memImprovements = [];
+    const cpuRegressions = [];
+    const cpuImprovements = [];
+    const newLeaks = [];
+    const resolvedLeaks = [];
+    let totalRetainedBefore = 0;
+    let totalRetainedAfter = 0;
+    let totalCpuBefore = 0;
+    let totalCpuAfter = 0;
+    for (const key of allKeys) {
+        const fb = funcsBefore.get(key);
+        const fa = funcsAfter.get(key);
+        const retBefore = fb ? fb.retainedBytes : 0;
+        const retAfter = fa ? fa.retainedBytes : 0;
+        const cpuBefore = fb ? fb.cpuSelf : 0;
+        const cpuAfter = fa ? fa.cpuSelf : 0;
+        totalRetainedBefore += retBefore;
+        totalRetainedAfter += retAfter;
+        totalCpuBefore += cpuBefore;
+        totalCpuAfter += cpuAfter;
+        const retDelta = retAfter - retBefore;
+        const cpuDelta = cpuAfter - cpuBefore;
+        const parts = key.split('|');
+        const funcName = parts[0];
+        const file = parts.slice(1).join('|');
+        const mod = fa?.module ?? fb?.module ?? '?';
+        // Track new / resolved leaks
+        if (!fb && fa && fa.retainedBytes > 0) {
+            newLeaks.push(funcName);
+        }
+        if (fb && !fa && fb.retainedBytes > 0) {
+            resolvedLeaks.push(funcName);
+        }
+        if (retDelta !== 0) {
+            const delta = {
+                function: funcName,
+                file,
+                module: mod,
+                retainedBefore: retBefore,
+                retainedAfter: retAfter,
+                delta: retDelta,
+                cpuBefore,
+                cpuAfter,
+                cpuDelta,
+            };
+            if (retDelta > 0) {
+                memRegressions.push(delta);
+            }
+            else {
+                memImprovements.push(delta);
+            }
+        }
+        if (cpuDelta !== 0) {
+            const delta = {
+                function: funcName,
+                file,
+                module: mod,
+                retainedBefore: retBefore,
+                retainedAfter: retAfter,
+                delta: retDelta,
+                cpuBefore,
+                cpuAfter,
+                cpuDelta,
+            };
+            if (cpuDelta > 0) {
+                cpuRegressions.push(delta);
+            }
+            else {
+                cpuImprovements.push(delta);
+            }
+        }
+    }
+    // Sort by absolute delta descending
+    memRegressions.sort((a, b) => b.delta - a.delta);
+    memImprovements.sort((a, b) => a.delta - b.delta);
+    cpuRegressions.sort((a, b) => (b.cpuDelta ?? 0) - (a.cpuDelta ?? 0));
+    cpuImprovements.sort((a, b) => (a.cpuDelta ?? 0) - (b.cpuDelta ?? 0));
+    const top = options.top ?? 30;
+    return {
+        before: { file: beforeFile, targetVersion: before.header.targetVersion },
+        after: { file: afterFile, targetVersion: after.header.targetVersion },
+        memoryDelta: {
+            totalRetainedBefore,
+            totalRetainedAfter,
+            totalRetainedDelta: totalRetainedAfter - totalRetainedBefore,
+            regressions: memRegressions.slice(0, top),
+            improvements: memImprovements.slice(0, top),
+            newLeaks,
+            resolvedLeaks,
+        },
+        cpuDelta: {
+            totalCpuBefore,
+            totalCpuAfter,
+            totalCpuDelta: totalCpuAfter - totalCpuBefore,
+            regressions: cpuRegressions.slice(0, top),
+            improvements: cpuImprovements.slice(0, top),
+        },
+    };
+}
+//# sourceMappingURL=DiffAnalyzer.js.map

package/dist/analyzer/MemoryAnalyzer.d.ts

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

package/dist/analyzer/MemoryAnalyzer.js

@@ -0,0 +1,47 @@
+import { aggregate, rankFunctions } from './Aggregator.js';
+import { buildHeaderInfo, buildParseStats } from './common.js';
+export function analyzeMemory(profile, options = {}) {
+    const top = options.top ?? 30;
+    const sortBy = options.sortBy ?? 'retained';
+    const threshold = options.threshold ?? 0;
+    const { byModule, byFile, byFunction } = aggregate(profile, options);
+    const moduleList = sortModules([...byModule.values()]);
+    const fileList = sortFiles([...byFile.values()], top);
+    const allFuncs = [...byFunction.values()];
+    const funcList = rankFunctions(allFuncs, sortBy, top, threshold);
+    const summary = buildMemorySummary(allFuncs, profile);
+    return {
+        header: buildHeaderInfo(profile),
+        summary,
+        byModule: moduleList,
+        byFile: fileList,
+        byFunction: funcList,
+    };
+}
+function buildMemorySummary(funcs, profile) {
+    let totalAllocBytes = 0;
+    let totalFreeBytes = 0;
+    let totalAllocCount = 0;
+    let totalFreeCount = 0;
+    for (const f of funcs) {
+        totalAllocBytes += f.allocBytes;
+        totalFreeBytes += f.freeBytes;
+        totalAllocCount += f.allocCount;
+        totalFreeCount += f.freeCount;
+    }
+    return {
+        totalAllocBytes,
+        totalFreeBytes,
+        totalRetainedBytes: totalAllocBytes - totalFreeBytes,
+        totalAllocCount,
+        totalFreeCount,
+        parseStats: buildParseStats(profile),
+    };
+}
+function sortModules(modules) {
+    return modules.sort((a, b) => b.retainedBytes - a.retainedBytes);
+}
+function sortFiles(files, top) {
+    return files.sort((a, b) => b.retainedBytes - a.retainedBytes).slice(0, top);
+}
+//# sourceMappingURL=MemoryAnalyzer.js.map

package/dist/analyzer/common.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedProfile, HeaderInfo, ParseStats } from '../parser/types.js';
+export declare function buildHeaderInfo(profile: ParsedProfile): HeaderInfo;
+export declare function buildParseStats(profile: ParsedProfile): ParseStats;
+//# sourceMappingURL=common.d.ts.map

package/dist/analyzer/common.js

@@ -0,0 +1,31 @@
+export function buildHeaderInfo(profile) {
+    const h = profile.header;
+    const durationMs = profile.timestampEnd !== undefined
+        ? Number(profile.timestampEnd - h.timestampStart)
+        : 0;
+    const features = [];
+    if (h.lineSpecificData)
+        features.push('line-specific-data');
+    if (h.memoryOperations)
+        features.push('memory-operations');
+    return {
+        targetName: h.targetName,
+        targetVersion: h.targetVersion,
+        device: `${h.deviceVendor} ${h.deviceModel}`.trim(),
+        firmware: h.deviceFirmware,
+        duration: durationMs,
+        fileSize: profile.fileSize,
+        formatVersion: `v${h.majorVersion}.${h.minorVersion}.${h.patchLevel}`,
+        features,
+    };
+}
+export function buildParseStats(profile) {
+    return {
+        entries: profile.parseResult.count,
+        errors: profile.parseResult.errors,
+        strings: profile.strings.size,
+        modules: profile.modules.size,
+        pathElements: profile.pathElements.size,
+    };
+}
+//# sourceMappingURL=common.js.map

package/dist/formatter/ChromeTraceExporter.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedProfile } from '../parser/types.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 declare class ChromeTraceExporter {
+    export(profile: ParsedProfile): string;
+    private addCallStackEvents;
+}
+//# sourceMappingURL=ChromeTraceExporter.d.ts.map