Every error spawns at a random low layer — Platform/OS, Network/IO, or Business Logic — and is first offered to its own local try/catch. If that layer doesn't catch it, the exception propagates up one layer at a time. Each layer along the way rolls against its own catch chance: catching means either handling it outright (stop, success) or retrying the original operation from scratch (the error's origin resets and it re-enters the stack, up to the retry limit before that layer just handles it as a fallback). An error that reaches the UI layer's global error boundary uncaught crashes the app — that boundary is fixed, only the layers below it are tunable.
layers (bottom→top): Platform(12% fixed) → Network → Business → UI(55% fixed)
at each layer:
roll < catch% → caught
50% of catches → handled (done)
50% of catches → retry (if retries < limit): reset to origin, else handled
roll ≥ catch% → propagate to next layer up
uncaught past UI → CRASH
- Error rate — how often a new exception is thrown somewhere in the stack.
- Network / Business catch % — how good each layer's own exception handling is; raising either intercepts more errors before they reach the UI.
- Retry limit — how many times a catching layer will retry the failed call locally instead of just swallowing it; a retried error falls back to its origin layer and climbs again.