Nothing to peek at.Nothing to slow down.

unpeek reads a 3-tier call graph before rewriting a token. 60fps loops and render bodies keep their original source; cold handlers enter a zero-escape O(1) vault and optional --aggressive Micro-VM.

Source
hot path
left byte for byte
cold path
92-char / 64-bit vault + Rivest MBA
integrity
order-free globalThis + host WASM
export function stepParticles(dt) {for (let i = 0; i < particles.length; i++) {particles[i].x += lerp(a, b, dt);const endpoint = "https://licensing.acme.dev/v2/verify";export async function verifyLicense(token) {const salt = "unpeek_prod_hmac_v2_99481a";return check(key, salt, endpoint);export function stepParticles(dt) {for (let i = 0; i < particles.length; i++) {particles[i].x += lerp(a, b, dt);const endpoint = "https://licensing.acme.dev/v2/verify";export async function verifyLicense(token) {const salt = "unpeek_prod_hmac_v2_99481a";return check(key, salt, endpoint);
export function stepParticles(dt) {for (let i = 0; i < particles.length; i++) {particles[i].x += lerp(a, b, dt);const _q1=_a4f[0];export async function verifyLicense($k0){const $m2=_a4f[1];return check($k0,$m2,_q1);}export function stepParticles(dt) {for (let i = 0; i < particles.length; i++) {particles[i].x += lerp(a, b, dt);const _q1=_a4f[0];export async function verifyLicense($k0){const $m2=_a4f[1];return check($k0,$m2,_q1);}
< 2%
Hot-path CPU overhead
< 15%
Gzip bundle delta
0 LOC
Application changes
100%
Source maps isolated

Default profile, measured by the benchmark suite in packages/unpeek/benchmarks.

The parser sees three execution tiers.

unpeek classifies your AST before rewriting a token: 60fps loops and direct UI component renders stay untouched, serialized Web Workers remain pristine, and nested handlers enter hardened cold paths.

Hot path (TRUE_HOT_60FPS & shallow render)

Loops, requestAnimationFrame, Three.js useFrame hooks, and direct component render bodies skip transformation cleanly. Nested async event handlers (onSubmit, handleSave) stay cold and protected.

Cold path & Tier 3 @unpeek-critical enclave

Auth checks, billing, API clients, and WebGPU shaders. Tier 2 applies a 92-char zero-escape O(1) vault, >=4-var semi-linear MBA + degree-3 Rivest QNR guards, and an in-place Uint8Array shader vault; Tier 3 / --aggressive adds a 43-opcode Micro-VM v2 and shared <1.2 KB host-coupled WASM KDF.

  1. 01ParseAcorn builds an AST for each client chunk. Server output is never opened.
  2. 02Classify3-tier graph separates TRUE_HOT_60FPS, SHALLOW_RENDER_COMPONENT, and SERIALIZED_WORKER.
  3. 03GuardCold paths receive >=4-var MBA, Rivest Z_2^32 QNR predicates, and neutral decoy bridges.
  4. 04Vault & VM92-char / 64-bit salted vault + Uint8Array shaders (--aggressive adds 43-op Micro-VM v2 + singleton WASM).
  5. 05SealOrder-independent globalThis shield attests integrity; multi-pass maps move to .unpeek-maps/.

Run the call graph yourself.

Same source, same seed. Turn the exemption off and watch the frame rate answer.

ExemptProtected
license-guard.ts
// license-guard.tsexport function renderFrame(t) {  for (let i = 0; i < particles.length; i++) {    particles[i].x += lerp(a, b, t);  }} export function validateLicense(key) {  const salt = "uNp33k_v4";  const url = "https://api.unpeek.dev/v1/license";  return check(key, salt, url);}
HOT PATH / EXEMPTCOLD PATH / VAULTEDrenderFrameEXEMPTlerpEXEMPTstepParticlesEXEMPTvalidateLicensecheckhmac
Frames per second
--fps
16.7 ms budget

Exempt: the loop runs as written.

Selection
renderFrame

Loop found. Flagged hot, then propagated to lerp and stepParticles.

Demo workload modeled on the project benchmark profile. Not a device benchmark.

What ships, and where it lands.

Every number below comes from the benchmark suite or the transform pipeline in this repository. Nothing is rounded up for the page.

Hot-path CPU overhead
under 2% (0% hot loop)
benchmarks/overhead.bench.ts
Gzip bundle delta
+4% to +8% (Tier 1/2)
src/core/protect.ts
Cold function transform
Rivest MBA + 43-op Micro-VM v2
src/ast
Shader & WebGPU vault
in-place re-encrypting Uint8Array
src/ast/string-vault.ts
Runtime shield
order-free globalThis + <1.2 KB WASM
src/runtime & wasm-vault.ts
Client bundle scope
static chunks only (workers isolated)
src/core/detector.ts

Measured against legacy obfuscation.

The tradeoff is not speed against secrecy. It is where the secrecy is spent.

Hot-path CPU
unpeek
< 2%, 3-tier exempt
legacy
+300% to +850%
Gzip delta
unpeek
+4% to +8% (zero-escape)
legacy
+120% to +340%

Both bars share one scale per row: the unpeek bar is the measured figure drawn against the legacy upper bound.

String decode
O(1) involutory / salted VM
Legacy obfuscator: O(N) per call
Source maps
Vaulted, URL stripped
Legacy obfuscator: Manual
Integrity check
Order-free globalThis + singleton WASM
Legacy obfuscator: Regex self-defense

Legacy figures are published ranges for control-flow flattening presets. unpeek figures come from this repository's benchmark run.

Reference

The full manual lives on its own page.

CLI flags, bundler adapters, hot-path heuristics, the source map vault, the programmatic API and the security model. Every section is written against this repository.

Open the documentation
  1. 01Installation & Quick Start03
  2. 02Framework Integrations03
  3. 03Three-Tier Architecture & 3-Tier Hot-Path Engine04
  4. 04Source Map Vault & Production Debugging03
  5. 05CLI Flags & Programmatic API Reference03
  6. 06Using unpeek with AI Coding Agents02
  7. 07Troubleshooting & Failure Modes03
  8. 08Security Model & Limits02

One line in postbuild.

unpeek reads the framework, finds the client output, and protects it. Server bundles stay readable.

No config file. No wrapper. Remove the postbuild line and the next build ships untouched.

postbuild
$ npx unpeek init