AfterPack
This page is available in English only.
View as Markdown

AfterPack Pro

Free protects your whole bundle uniformly. Pro lets you apply the heaviest protection only where it matters: per region, per file. It also keeps a record of every build.

Free is the baseline: the full transform catalog, applied uniformly across your bundle, on your machine, for nothing. Pro is for a bundle that isn't uniform, when one license check, one pricing routine, or one embedded credential is worth far more than the rest of the code around it.

Pro changes where protection lands and how precisely. It does not change the strength of any single transform. Both tiers can drive complexity as high as your size budget allows.

What Free already gives you

Not a capped trial. Free runs the full pipeline: complexity is unbounded and every preset on the ladder is available.

  • Every preset: minify (target 0), light (2), medium (8), hard (25), extreme (80), plus any raw numeric target you set. The default is light.
  • Every transform. Literal lowering, control-flow flattening, opaque predicates, mixed boolean arithmetic, integer-expression bytecode, constant materialization, scope deepening, cross-dependency entanglement.
  • A new structure every build. Omit the seed for a fresh one per build; pin it when you need reproducible output.
  • Everything else you'd expect: Protection Map, source maps, framework plugins, framework detection. No account, no key, no network call for the obfuscation itself.
  • Debug-friendly by default. Devtools, breakpoints, console.log and watch expressions keep working. See Diagnostics when a build reports something.

Each preset caps output size: light allows 2.0× the raw input, medium 2.5×, hard 4.0×, extreme 7.0×. Pro lets you spend that budget only where it pays, instead of raising it for the whole bundle.

One engine compiles to two build targets, a native binary and WebAssembly. Both have a free build; the Pro engine runs only in AfterPack's cloudAfterPack engineone core, two build targetscompiles toNative binary@afterpack/coreWebAssembly@afterpack/wasm, and the cloudFree CLIruns on your machineFreePro cloudruns in AfterPack's cloudProPro transforms not includedPro transforms run hereBoth targets have a free build you can run yourself. Pro protection runs only in the cloud, never in code you ship.

What Pro buys

Protection you can aim

On Free, your configuration applies to every node in the bundle equally. On Pro, a marked region overrides your global settings.

In practice that means you can leave the bundle at light for fast builds and small output, and still put extreme on the twenty lines that actually matter:

/* @afterpack preset=hard */
function verifyLicense(token) {
  // raised to complexity target 25, string floor forced on
}
/* @afterpack end */

/* @afterpack skip */
function debugPanel() {
  // target 0, floor off — left alone
}
/* @afterpack end */

Regions come from @afterpack block comments. Directives are read from your source by the plugin.

What a directive can set: any option that applies per region.

How directives reach the engine

The plugin doing the reading is @afterpack/next, @afterpack/vite, @afterpack/webpack, or the rest. A Pro build driven by npx afterpack@latest <path> still gets the Pro engine and its regions.

Hardening for license and payment paths

Two protections you can switch on that Free builds do not apply:

SettingWhat it does for you
transforms.selfIntegrity.enabledTampering with the protected artifact corrupts its own decoding, so a patched build breaks instead of running normally. Untouched, it changes nothing.
transforms.comparisonHardening.enabledA string equality gate becomes a one-way digest check, so the literal you compare against is absent from the artifact entirely.

Both default off. Acknowledging a flagged reflection pattern works the same on either tier: reflection.allow in your configuration. It is not directive-settable.

Builds run on AfterPack's infrastructure

A key routes your build's files to AfterPack's cloud, which returns protected output as each file finishes. Nothing extra to install, and nothing to keep updated.

Source is processed in memory and is not persisted. See Deployment modes for what changes when the engine moves.

A record of every build

A cloud build is a recorded build. AfterPack stores that build's Protection Map plus a row of summary metrics, so the dashboard can show any recent build's map, diagnostics and timings. This answers "was that release actually protected?" without rerunning anything. Storage is per-project and can be switched off. Retention is one year and the last 500 builds per project, whichever runs out first. Usage is metered by the megabyte. See What Pro costs.

The full capability matrix, tier by tier, is in Plans & tiers.

What Pro costs

Pro meters usage rather than seats. What you buy is MB of JavaScript the cloud engine processes: not builds, not files, not requests. Every tier, Free included, has unlimited workspace members.

A Pro key routes your whole client bundle through the cloud engine, and every byte it processes is metered, including code outside your marked regions. A 1.5 MB Next.js client bundle uses 1.5 MB of the monthly allowance on every build.

There are three ways to get Pro capacity:

  • Free, registered: 10 MB a month, no card. Enough to put the surgical features on a real bundle and compare the output. See Accounts.
  • Extra MB: $5 for 20 MB, one-time. Never expires, never auto-renews, and buying one does not start a subscription. A project that ships a release every few weeks can run on top-ups alone.
  • A plan, from $49/mo, once volume makes it cheaper. Indie includes 500 MB a month, Team 3 GB, Studio 8 GB, each with automatic per-MB overage so a busy sprint doesn't fail CI. Indie and Team include a 14-day trial.

A build draws plan allowance, then Extra MB, then overage, in that order, so a top-up sits behind your monthly allowance instead of being spent first. Prices, project limits, the overage rates and the spend cap are in Plans & tiers.

For scale, a typical production SPA bundle is a few hundred KB to a couple of MB. The free 10 MB covers several real builds, and Indie's 500 MB covers a few hundred.

Soon

Not available today. These are the Pro items on the public roadmap, which is where AfterPack states what is coming and carries no dates.

CapabilityWhat it would add
Cross-module obfuscationEntanglement across module boundaries instead of within a file.
Network transport cloakingA per-build codec for your API requests and responses on the wire.
Managed source mapsProduction stack traces symbolicated through an authenticated lookup, without a map ever shipping.
Per-request builds from AfterPack's cloudA new shape per request or per rotation window, served by AfterPack, without running a Worker yourself.

What a Pro-only setting does on a Free build

A Free build stops on a per-region directive rather than applying less protection than the source asked for. The two hardening settings above are simply not applied. A Pro build that cannot reach the cloud fails closed.

Next