Every Pro Cloud build leaves a record: when it ran, which commit it came from, what it cost, how much of it the engine could transform, and what the engine reported while doing it. Free local builds never contact AfterPack, so they never appear here.
The build list
Every build of one project, newest first.
| Column | What it is |
|---|---|
| Built | When the build ran. |
| Commit | The git SHA AfterPack detected for the build (see seed), shown short and copied in full, pairing the row to a deploy. |
| Files | Output files this build sent to AfterPack, excluding the source files inside them. |
| Output | What shipped after protection. |
| Billed | The input bytes AfterPack processed. This is what you are charged for. |
| Build time | The time AfterPack added to the build, measured at the edge; older builds lack this record, so those rows show as absent instead of 0. |
| Coverage | Share of the received output the engine was free to transform. |
| Inflation | Output ÷ input. This is what protection costs your users to download. |
The list shows this project's most recent builds. While viewing a build, the sidebar nests that project's neighboring builds under Builds, letting you compare two in one click.
One build, in full
Open a row and the header carries the commit (or the build id with no git context) and the View Protection Map button, or a No map stored chip when there is nothing to open.
Outcome
Four numbers, and each one answers a different question.
- Coverage: the share of the received output the engine was free to transform.
- Inflation: output ÷ input size, the number your users pay for. Some growth is expected, since the transforms that make code hard to read take space.
- Complexity: the mean complexity reached across the eligible bytes, shown against this build's target (
score / target). Complexity is advisory and does not measure security. - Size: what went in, and what shipped.
Coverage composition
Where every byte of the input went. The bands sum to the input, and their shares match Coverage above.
| Band | Meaning |
|---|---|
| Eligible | Bytes the engine was free to transform. |
| Safety-preserved | Bytes the engine could not reach because it could not safely represent those constructs. |
| Reflection-preserved | Bytes preserved because your code uses runtime reflection. |
| You excluded | Files matched by your paths.exclude setting, skipped before parsing and returned unchanged. |
| You skipped | Regions you marked /* @afterpack skip */. |
| Unaccounted | Input bytes in no other band. |
Alongside the bands: weak spots (regions the engine flagged as recoverable; open the map to see where) and directives (the @afterpack markers the engine found in your source, recorded here, which is how you confirm one was picked up).
Source files
A treemap of every source file in the build, sized by the bytes that went in and colored by how far the engine got: grey tiles had nothing to act on, red tiles mean something went wrong, and orange to green shows weak to strong. Tiles cover only output that is traceable back to a file, roughly half of what you ship, so a tile's inflation is not the build's inflation. The rest is the runtime AfterPack injects once per bundle. Shared runtime code has no tile, which is why a build inflates more than any single file does.
This row is gated to paid plans: a Free workspace sees a locked state instead of the treemap, though every other row on the build page is free.
Output file capture
This tells you how many of the build's output files are viewable in the stored map, and what happened to the rest; it does not measure protection, since every file was obfuscated regardless of whether it was captured. One exception: if a build hits AfterPack's time budget, it stops starting new files, and every remaining file fails. Re-run the build, or split it into smaller builds.
Time
The time the build spent at AfterPack's edge, including waiting for the response to download. A large share of it is the Protection Map: producing and returning it adds to the obfuscation time, so turning capture off in project settings reclaims that time.
Billing
What this build drew from your workspace: Metered (the input bytes billed) and where it came from: Allowance, Credit (Extra MB), Overage.
Diagnostics
What the engine reported while obfuscating this build, grouped by a stable code with a count; because this is your own build in your own workspace, you also see the message and file for each entry. Informational entries are expected, so only errors and criticals are highlighted.
The page states which of three things happened: entries were recorded, the build was clean and reported nothing, or AfterPack holds no record at all, which is what a Free build leaves.
Each code is stable and quotable in a bug report. See Diagnostics.
The Protection Map
When capture is on and the build stored one, View Protection Map opens the per-token view: your original source, colored by each token's complexity score, with the reversal class of the code you select. A stored map embeds your original source and is readable by everyone in the workspace; retention and the per-project switch are on Privacy & data handling, and this page states the exact retention date for the build. A build with no stored map states the reason instead: capture was off, it was not a Pro Cloud build, or it carried no input source maps to build one from.
Trends
The project overview draws coverage, inflation, and build time over time at an adaptive bucket size, with a delta against the previous week or month; the workspace overview does the same for usage across every project.
Next
- Protection Map: reading the artifact itself.
- Reversal classes: what the class labels mean.
- Diagnostics: the codes the engine emits.
- Build & CI: producing these builds in the first place.
- Usage & billing: where the metered bytes go.